]> 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
Added the PseudoDC class from Paul Lanier. It provides a way to
[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 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_long swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2481 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2482 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2484 #define SWIGTYPE_p_wxColour swig_types[18]
2485 #define SWIGTYPE_p_wxColourData swig_types[19]
2486 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2488 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2489 #define SWIGTYPE_p_wxControl swig_types[23]
2490 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2491 #define SWIGTYPE_p_wxDC swig_types[25]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDialog swig_types[27]
2494 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2495 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2496 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2499 #define SWIGTYPE_p_wxEvent swig_types[33]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[34]
2501 #define SWIGTYPE_p_wxFSFile swig_types[35]
2502 #define SWIGTYPE_p_wxFileDialog swig_types[36]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[37]
2504 #define SWIGTYPE_p_wxFindDialogEvent swig_types[38]
2505 #define SWIGTYPE_p_wxFindReplaceData swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[40]
2507 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2508 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2509 #define SWIGTYPE_p_wxFont swig_types[43]
2510 #define SWIGTYPE_p_wxFontData swig_types[44]
2511 #define SWIGTYPE_p_wxFontDialog swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2514 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2515 #define SWIGTYPE_p_wxGrid swig_types[49]
2516 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2517 #define SWIGTYPE_p_wxGridCellAttr swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellCoords swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellEditor swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellWorker swig_types[70]
2537 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[71]
2538 #define SWIGTYPE_p_wxGridEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridSizeEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizer swig_types[75]
2542 #define SWIGTYPE_p_wxGridStringTable swig_types[76]
2543 #define SWIGTYPE_p_wxGridTableBase swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableMessage swig_types[78]
2545 #define SWIGTYPE_p_wxICOHandler swig_types[79]
2546 #define SWIGTYPE_p_wxIconizeEvent swig_types[80]
2547 #define SWIGTYPE_p_wxIdleEvent swig_types[81]
2548 #define SWIGTYPE_p_wxImage swig_types[82]
2549 #define SWIGTYPE_p_wxImageHandler swig_types[83]
2550 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[84]
2551 #define SWIGTYPE_p_wxInitDialogEvent swig_types[85]
2552 #define SWIGTYPE_p_wxJPEGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxKeyEvent swig_types[87]
2554 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[88]
2555 #define SWIGTYPE_p_wxLayoutConstraints swig_types[89]
2556 #define SWIGTYPE_p_wxMDIChildFrame swig_types[90]
2557 #define SWIGTYPE_p_wxMDIClientWindow swig_types[91]
2558 #define SWIGTYPE_p_wxMDIParentFrame swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMessageDialog swig_types[98]
2565 #define SWIGTYPE_p_wxMiniFrame swig_types[99]
2566 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMoveEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[103]
2570 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNcPaintEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNotifyEvent swig_types[106]
2573 #define SWIGTYPE_p_wxObject swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPageSetupDialog swig_types[111]
2578 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[112]
2579 #define SWIGTYPE_p_wxPaintEvent swig_types[113]
2580 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPanel swig_types[115]
2582 #define SWIGTYPE_p_wxPaperSize swig_types[116]
2583 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[117]
2584 #define SWIGTYPE_p_wxPoint swig_types[118]
2585 #define SWIGTYPE_p_wxPopupWindow swig_types[119]
2586 #define SWIGTYPE_p_wxPreviewCanvas swig_types[120]
2587 #define SWIGTYPE_p_wxPreviewControlBar swig_types[121]
2588 #define SWIGTYPE_p_wxPreviewFrame swig_types[122]
2589 #define SWIGTYPE_p_wxPrintData swig_types[123]
2590 #define SWIGTYPE_p_wxPrintDialog swig_types[124]
2591 #define SWIGTYPE_p_wxPrintDialogData swig_types[125]
2592 #define SWIGTYPE_p_wxPrintPreview swig_types[126]
2593 #define SWIGTYPE_p_wxPrinter swig_types[127]
2594 #define SWIGTYPE_p_wxProgressDialog swig_types[128]
2595 #define SWIGTYPE_p_wxPyApp swig_types[129]
2596 #define SWIGTYPE_p_wxPyCommandEvent swig_types[130]
2597 #define SWIGTYPE_p_wxPyEvent swig_types[131]
2598 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[132]
2599 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[133]
2600 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[134]
2601 #define SWIGTYPE_p_wxPyGridTableBase swig_types[135]
2602 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[136]
2603 #define SWIGTYPE_p_wxPyImageHandler swig_types[137]
2604 #define SWIGTYPE_p_wxPyPanel swig_types[138]
2605 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[139]
2606 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[140]
2607 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[141]
2608 #define SWIGTYPE_p_wxPyPrintPreview swig_types[142]
2609 #define SWIGTYPE_p_wxPyPrintout swig_types[143]
2610 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[144]
2611 #define SWIGTYPE_p_wxPySizer swig_types[145]
2612 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[146]
2613 #define SWIGTYPE_p_wxPyVListBox swig_types[147]
2614 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[148]
2615 #define SWIGTYPE_p_wxPyValidator swig_types[149]
2616 #define SWIGTYPE_p_wxPyWindow swig_types[150]
2617 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[151]
2618 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[152]
2619 #define SWIGTYPE_p_wxRect swig_types[153]
2620 #define SWIGTYPE_p_wxSashEvent swig_types[154]
2621 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[155]
2622 #define SWIGTYPE_p_wxSashWindow swig_types[156]
2623 #define SWIGTYPE_p_wxScrollEvent swig_types[157]
2624 #define SWIGTYPE_p_wxScrollWinEvent swig_types[158]
2625 #define SWIGTYPE_p_wxScrolledWindow swig_types[159]
2626 #define SWIGTYPE_p_wxSetCursorEvent swig_types[160]
2627 #define SWIGTYPE_p_wxShowEvent swig_types[161]
2628 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[162]
2629 #define SWIGTYPE_p_wxSizeEvent swig_types[163]
2630 #define SWIGTYPE_p_wxSizer swig_types[164]
2631 #define SWIGTYPE_p_wxSizerItem swig_types[165]
2632 #define SWIGTYPE_p_wxSplashScreen swig_types[166]
2633 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[167]
2634 #define SWIGTYPE_p_wxSplitterEvent swig_types[168]
2635 #define SWIGTYPE_p_wxSplitterWindow swig_types[169]
2636 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[170]
2637 #define SWIGTYPE_p_wxStatusBar swig_types[171]
2638 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[172]
2639 #define SWIGTYPE_p_wxString swig_types[173]
2640 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[174]
2641 #define SWIGTYPE_p_wxTIFFHandler swig_types[175]
2642 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[176]
2643 #define SWIGTYPE_p_wxTextEntryDialog swig_types[177]
2644 #define SWIGTYPE_p_wxTipWindow swig_types[178]
2645 #define SWIGTYPE_p_wxTopLevelWindow swig_types[179]
2646 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[180]
2647 #define SWIGTYPE_p_wxValidator swig_types[181]
2648 #define SWIGTYPE_p_wxVisualAttributes swig_types[182]
2649 #define SWIGTYPE_p_wxWindow swig_types[183]
2650 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[184]
2651 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[185]
2652 #define SWIGTYPE_p_wxXPMHandler swig_types[186]
2653 static swig_type_info *swig_types[188];
2654 static swig_module_info swig_module = {swig_types, 187, 0, 0, 0, 0};
2655 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2656 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2657
2658 /* -------- TYPES TABLE (END) -------- */
2659
2660 #if (PY_VERSION_HEX <= 0x02000000)
2661 # if !defined(SWIG_PYTHON_CLASSIC)
2662 # error "This python version requires to use swig with the '-classic' option"
2663 # endif
2664 #endif
2665 #if (PY_VERSION_HEX <= 0x02020000)
2666 # error "This python version requires to use swig with the '-nomodern' option"
2667 #endif
2668 #if (PY_VERSION_HEX <= 0x02020000)
2669 # error "This python version requires to use swig with the '-nomodernargs' option"
2670 #endif
2671 #ifndef METH_O
2672 # error "This python version requires to use swig with the '-nofastunpack' option"
2673 #endif
2674
2675 /*-----------------------------------------------
2676 @(target):= _grid.so
2677 ------------------------------------------------*/
2678 #define SWIG_init init_grid
2679
2680 #define SWIG_name "_grid"
2681
2682 #define SWIGVERSION 0x010329
2683
2684
2685 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2686 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2687
2688
2689 #include <stdexcept>
2690
2691
2692 namespace swig {
2693 class PyObject_ptr {
2694 protected:
2695 PyObject *_obj;
2696
2697 public:
2698 PyObject_ptr() :_obj(0)
2699 {
2700 }
2701
2702 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2703 {
2704 Py_XINCREF(_obj);
2705 }
2706
2707 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2708 {
2709 if (initial_ref) Py_XINCREF(_obj);
2710 }
2711
2712 PyObject_ptr & operator=(const PyObject_ptr& item)
2713 {
2714 Py_XINCREF(item._obj);
2715 Py_XDECREF(_obj);
2716 _obj = item._obj;
2717 return *this;
2718 }
2719
2720 ~PyObject_ptr()
2721 {
2722 Py_XDECREF(_obj);
2723 }
2724
2725 operator PyObject *() const
2726 {
2727 return _obj;
2728 }
2729
2730 PyObject *operator->() const
2731 {
2732 return _obj;
2733 }
2734 };
2735 }
2736
2737
2738 namespace swig {
2739 struct PyObject_var : PyObject_ptr {
2740 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2741
2742 PyObject_var & operator = (PyObject* obj)
2743 {
2744 Py_XDECREF(_obj);
2745 _obj = obj;
2746 return *this;
2747 }
2748 };
2749 }
2750
2751
2752 #include "wx/wxPython/wxPython.h"
2753 #include "wx/wxPython/pyclasses.h"
2754 #include "wx/wxPython/printfw.h"
2755
2756 #include <wx/grid.h>
2757 #include <wx/generic/gridctrl.h>
2758
2759
2760 static const wxString wxPyEmptyString(wxEmptyString);
2761 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2762 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2763
2764
2765 #define wxPyMake_TEMPLATE(TYPE) \
2766 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2767 PyObject* target = NULL; \
2768 if (source) { \
2769 /* Check if there is already a pointer to a Python object in the \
2770 OOR data that we can use. */ \
2771 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2772 if (data) { \
2773 target = data->m_obj; \
2774 if (target) \
2775 Py_INCREF(target); \
2776 } \
2777 /* Otherwise make a new wrapper for it the old fashioned way and \
2778 give it the OOR treatment */ \
2779 if (! target) { \
2780 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2781 if (target) \
2782 source->SetClientObject(new wxPyOORClientData(target)); \
2783 } \
2784 } else { /* source was NULL so return None. */ \
2785 Py_INCREF(Py_None); target = Py_None; \
2786 } \
2787 return target; \
2788 } \
2789
2790
2791 wxPyMake_TEMPLATE(wxGridCellRenderer)
2792 wxPyMake_TEMPLATE(wxGridCellEditor)
2793 wxPyMake_TEMPLATE(wxGridCellAttr)
2794 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2795 wxPyMake_TEMPLATE(wxGridTableBase)
2796
2797
2798
2799 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2800 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2801 wxGridCellAttr* rval = NULL; \
2802 bool found; \
2803 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2804 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2805 PyObject* ro; \
2806 wxGridCellAttr* ptr; \
2807 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2808 if (ro) { \
2809 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2810 rval = ptr; \
2811 Py_DECREF(ro); \
2812 } \
2813 } \
2814 wxPyEndBlockThreads(blocked); \
2815 if (! found) \
2816 rval = PCLASS::CBNAME(a, b, c); \
2817 return rval; \
2818 }
2819
2820
2821 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2822 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2823 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2824 bool found; \
2825 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2826 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2827 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2828 Py_DECREF(obj); \
2829 } \
2830 wxPyEndBlockThreads(blocked); \
2831 if (! found) \
2832 PCLASS::CBNAME(attr, a, b); \
2833 }
2834
2835
2836
2837 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2838 void CBNAME(wxGridCellAttr *attr, int val) { \
2839 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2840 bool found; \
2841 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2842 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2843 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2844 Py_DECREF(obj); \
2845 } \
2846 wxPyEndBlockThreads(blocked); \
2847 if (! found) \
2848 PCLASS::CBNAME(attr, val); \
2849 }
2850
2851
2852
2853 #define PYCALLBACK_INT__pure(CBNAME) \
2854 int CBNAME() { \
2855 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2856 int rval = 0; \
2857 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2858 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2859 wxPyEndBlockThreads(blocked); \
2860 return rval; \
2861 }
2862
2863
2864
2865 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2866 bool CBNAME(int a, int b) { \
2867 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2868 bool rval = 0; \
2869 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2870 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2871 wxPyEndBlockThreads(blocked); \
2872 return rval; \
2873 }
2874
2875
2876 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2877 wxString CBNAME(int a, int b) { \
2878 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2879 wxString rval; \
2880 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2881 PyObject* ro; \
2882 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2883 if (ro) { \
2884 rval = Py2wxString(ro); \
2885 Py_DECREF(ro); \
2886 } \
2887 } \
2888 wxPyEndBlockThreads(blocked); \
2889 return rval; \
2890 }
2891
2892
2893 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2894 void CBNAME(int a, int b, const wxString& c) { \
2895 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2896 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2897 PyObject* s = wx2PyString(c); \
2898 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2899 Py_DECREF(s); \
2900 } \
2901 wxPyEndBlockThreads(blocked); \
2902 }
2903
2904
2905 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2906 wxString CBNAME(int a, int b) { \
2907 bool found; \
2908 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2909 wxString rval; \
2910 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2911 PyObject* ro; \
2912 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2913 if (ro) { \
2914 rval = Py2wxString(ro); \
2915 Py_DECREF(ro); \
2916 } \
2917 } \
2918 wxPyEndBlockThreads(blocked); \
2919 if (! found) \
2920 rval = PCLASS::CBNAME(a, b); \
2921 return rval; \
2922 }
2923
2924
2925 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2926 bool CBNAME(int a, int b, const wxString& c) { \
2927 bool rval = 0; \
2928 bool found; \
2929 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2930 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2931 PyObject* s = wx2PyString(c); \
2932 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2933 Py_DECREF(s); \
2934 } \
2935 wxPyEndBlockThreads(blocked); \
2936 if (! found) \
2937 rval = PCLASS::CBNAME(a,b,c); \
2938 return rval; \
2939 }
2940
2941
2942
2943
2944 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2945 long CBNAME(int a, int b) { \
2946 long rval; \
2947 bool found; \
2948 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2949 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2950 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2951 wxPyEndBlockThreads(blocked); \
2952 if (! found) \
2953 rval = PCLASS::CBNAME(a,b); \
2954 return rval; \
2955 }
2956
2957
2958 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2959 bool CBNAME(int a, int b) { \
2960 bool rval = 0; \
2961 bool found; \
2962 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2963 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2964 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2965 wxPyEndBlockThreads(blocked); \
2966 if (! found) \
2967 rval = PCLASS::CBNAME(a,b); \
2968 return rval; \
2969 }
2970
2971
2972
2973 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2974 double CBNAME(int a, int b) { \
2975 bool found; \
2976 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2977 double rval; \
2978 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2979 PyObject* ro; \
2980 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2981 if (ro) { \
2982 PyObject* str = PyObject_Str(ro); \
2983 rval = PyFloat_AsDouble(str); \
2984 Py_DECREF(ro); Py_DECREF(str); \
2985 } \
2986 } \
2987 wxPyEndBlockThreads(blocked); \
2988 if (! found) \
2989 rval = PCLASS::CBNAME(a, b); \
2990 return rval; \
2991 }
2992
2993
2994
2995 #define PYCALLBACK__(PCLASS, CBNAME) \
2996 void CBNAME() { \
2997 bool found; \
2998 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2999 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3000 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3001 wxPyEndBlockThreads(blocked); \
3002 if (! found) \
3003 PCLASS::CBNAME(); \
3004 }
3005
3006
3007
3008 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3009 bool CBNAME(size_t a, size_t b) { \
3010 bool rval = 0; \
3011 bool found; \
3012 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3013 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3014 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3015 wxPyEndBlockThreads(blocked); \
3016 if (! found) \
3017 rval = PCLASS::CBNAME(a,b); \
3018 return rval; \
3019 }
3020
3021
3022
3023 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3024 bool CBNAME(size_t a) { \
3025 bool rval = 0; \
3026 bool found; \
3027 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3028 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3029 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3030 wxPyEndBlockThreads(blocked); \
3031 if (! found) \
3032 rval = PCLASS::CBNAME(a); \
3033 return rval; \
3034 }
3035
3036
3037 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3038 wxString CBNAME(int a) { \
3039 bool found; \
3040 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3041 wxString rval; \
3042 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3043 PyObject* ro; \
3044 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3045 if (ro) { \
3046 rval = Py2wxString(ro); \
3047 Py_DECREF(ro); \
3048 } \
3049 } \
3050 wxPyEndBlockThreads(blocked); \
3051 if (! found) \
3052 rval = PCLASS::CBNAME(a); \
3053 return rval; \
3054 }
3055
3056
3057 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3058 void CBNAME(int a, const wxString& c) { \
3059 bool found; \
3060 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3061 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3062 PyObject* s = wx2PyString(c); \
3063 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3064 Py_DECREF(s); \
3065 } \
3066 wxPyEndBlockThreads(blocked); \
3067 if (! found) \
3068 PCLASS::CBNAME(a,c); \
3069 }
3070
3071
3072
3073
3074 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3075 bool CBNAME() { \
3076 bool rval = 0; \
3077 bool found; \
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3079 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3080 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3081 wxPyEndBlockThreads(blocked); \
3082 if (! found) \
3083 rval = PCLASS::CBNAME(); \
3084 return rval; \
3085 }
3086
3087
3088
3089 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3090 void CBNAME(size_t a, int b) { \
3091 bool found; \
3092 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3093 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3094 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3095 wxPyEndBlockThreads(blocked); \
3096 if (! found) \
3097 PCLASS::CBNAME(a,b); \
3098 }
3099
3100
3101
3102
3103 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3104 void CBNAME(int a, int b, long c) { \
3105 bool found; \
3106 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3107 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3108 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3109 wxPyEndBlockThreads(blocked); \
3110 if (! found) \
3111 PCLASS::CBNAME(a,b,c); \
3112 }
3113
3114
3115
3116
3117 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3118 void CBNAME(int a, int b, double c) { \
3119 bool found; \
3120 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3121 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3122 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3123 wxPyEndBlockThreads(blocked); \
3124 if (! found) \
3125 PCLASS::CBNAME(a,b,c); \
3126 }
3127
3128
3129
3130 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3131 void CBNAME(int a, int b, bool c) { \
3132 bool found; \
3133 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3134 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3135 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3136 wxPyEndBlockThreads(blocked); \
3137 if (! found) \
3138 PCLASS::CBNAME(a,b,c); \
3139 }
3140
3141
3142
3143
3144
3145 SWIGINTERN swig_type_info*
3146 SWIG_pchar_descriptor()
3147 {
3148 static int init = 0;
3149 static swig_type_info* info = 0;
3150 if (!init) {
3151 info = SWIG_TypeQuery("_p_char");
3152 init = 1;
3153 }
3154 return info;
3155 }
3156
3157
3158 SWIGINTERNINLINE PyObject *
3159 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3160 {
3161 if (carray) {
3162 if (size > INT_MAX) {
3163 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3164 return pchar_descriptor ?
3165 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3166 } else {
3167 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3168 }
3169 } else {
3170 return SWIG_Py_Void();
3171 }
3172 }
3173
3174
3175 SWIGINTERNINLINE PyObject *
3176 SWIG_FromCharPtr(const char *cptr)
3177 {
3178 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3179 }
3180
3181
3182 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3183 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3184 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3185 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3186 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3187 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3188 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3189 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3190 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3191 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3192
3193
3194 #define SWIG_From_long PyInt_FromLong
3195
3196
3197 SWIGINTERNINLINE PyObject *
3198 SWIG_From_int (int value)
3199 {
3200 return SWIG_From_long (value);
3201 }
3202
3203 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3204 if (!self->GetClientObject())
3205 self->SetClientObject(new wxPyOORClientData(_self));
3206 }
3207 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3208 }
3209
3210 class wxPyGridCellRenderer : public wxGridCellRenderer
3211 {
3212 public:
3213 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3214
3215 // Implement Python callback aware virtual methods
3216 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3217 wxDC& dc, const wxRect& rect,
3218 int row, int col, bool isSelected) {
3219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3220 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3221 PyObject* go = wxPyMake_wxObject(&grid,false);
3222 PyObject* dco = wxPyMake_wxObject(&dc,false);
3223 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3224 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3225
3226 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3227 row, col, isSelected));
3228 Py_DECREF(go);
3229 Py_DECREF(ao);
3230 Py_DECREF(dco);
3231 Py_DECREF(ro);
3232 }
3233 wxPyEndBlockThreads(blocked);
3234 }
3235
3236 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3237 int row, int col) {
3238 wxSize rval;
3239 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3240 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3241 PyObject* ro;
3242 wxSize* ptr;
3243 PyObject* go = wxPyMake_wxObject(&grid,false);
3244 PyObject* dco = wxPyMake_wxObject(&dc,false);
3245 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3246
3247 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3248 go, ao, dco,
3249 row, col));
3250 Py_DECREF(go);
3251 Py_DECREF(ao);
3252 Py_DECREF(dco);
3253
3254 if (ro) {
3255 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3256 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3257 rval = *ptr;
3258 }
3259 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3260 PyObject* o1 = PySequence_GetItem(ro, 0);
3261 PyObject* o2 = PySequence_GetItem(ro, 1);
3262 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3263 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3264 else
3265 PyErr_SetString(PyExc_TypeError, errmsg);
3266 Py_DECREF(o1);
3267 Py_DECREF(o2);
3268 }
3269 else {
3270 PyErr_SetString(PyExc_TypeError, errmsg);
3271 }
3272 Py_DECREF(ro);
3273 }
3274 }
3275 wxPyEndBlockThreads(blocked);
3276 return rval;
3277 }
3278
3279
3280 wxGridCellRenderer *Clone() const {
3281 wxGridCellRenderer* rval = NULL;
3282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3283 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3284 PyObject* ro;
3285 wxGridCellRenderer* ptr;
3286 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3287 if (ro) {
3288 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3289 rval = ptr;
3290 Py_DECREF(ro);
3291 }
3292 }
3293 wxPyEndBlockThreads(blocked);
3294 return rval;
3295 }
3296
3297 DEC_PYCALLBACK__STRING(SetParameters);
3298
3299 PYPRIVATE;
3300 };
3301
3302 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3303
3304
3305
3306 #include <limits.h>
3307 #ifndef LLONG_MIN
3308 # define LLONG_MIN LONG_LONG_MIN
3309 #endif
3310 #ifndef LLONG_MAX
3311 # define LLONG_MAX LONG_LONG_MAX
3312 #endif
3313 #ifndef ULLONG_MAX
3314 # define ULLONG_MAX ULONG_LONG_MAX
3315 #endif
3316
3317
3318 SWIGINTERN int
3319 SWIG_AsVal_long (PyObject* obj, long* val)
3320 {
3321 if (PyNumber_Check(obj)) {
3322 if (val) *val = PyInt_AsLong(obj);
3323 return SWIG_OK;
3324 }
3325 return SWIG_TypeError;
3326 }
3327
3328
3329 SWIGINTERN int
3330 SWIG_AsVal_int (PyObject * obj, int *val)
3331 {
3332 long v;
3333 int res = SWIG_AsVal_long (obj, &v);
3334 if (SWIG_IsOK(res)) {
3335 if ((v < INT_MIN || v > INT_MAX)) {
3336 return SWIG_OverflowError;
3337 } else {
3338 if (val) *val = static_cast< int >(v);
3339 }
3340 }
3341 return res;
3342 }
3343
3344
3345 SWIGINTERN int
3346 SWIG_AsVal_bool (PyObject *obj, bool *val)
3347 {
3348 if (obj == Py_True) {
3349 if (val) *val = true;
3350 return SWIG_OK;
3351 } else if (obj == Py_False) {
3352 if (val) *val = false;
3353 return SWIG_OK;
3354 } else {
3355 long v = 0;
3356 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3357 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3358 return res;
3359 }
3360 }
3361
3362
3363 class wxPyGridCellEditor : public wxGridCellEditor
3364 {
3365 public:
3366 wxPyGridCellEditor() : wxGridCellEditor() {}
3367
3368 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3369 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3370 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3371 PyObject* po = wxPyMake_wxObject(parent,false);
3372 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3373
3374 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3375 Py_DECREF(po);
3376 Py_DECREF(eo);
3377 }
3378 wxPyEndBlockThreads(blocked);
3379 }
3380
3381
3382 void BeginEdit(int row, int col, wxGrid* grid) {
3383 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3384 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3385 PyObject* go = wxPyMake_wxObject(grid,false);
3386 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3387 Py_DECREF(go);
3388 }
3389 wxPyEndBlockThreads(blocked);
3390 }
3391
3392
3393 bool EndEdit(int row, int col, wxGrid* grid) {
3394 bool rv = false;
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3397 PyObject* go = wxPyMake_wxObject(grid,false);
3398 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3399 Py_DECREF(go);
3400 }
3401 wxPyEndBlockThreads(blocked);
3402 return rv;
3403 }
3404
3405
3406 wxGridCellEditor* Clone() const {
3407 wxGridCellEditor* rval = NULL;
3408 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3409 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3410 PyObject* ro;
3411 wxGridCellEditor* ptr;
3412 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3413 if (ro) {
3414 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3415 rval = ptr;
3416 Py_DECREF(ro);
3417 }
3418 }
3419 wxPyEndBlockThreads(blocked);
3420 return rval;
3421 }
3422
3423
3424 void Show(bool show, wxGridCellAttr *attr) {
3425 bool found;
3426 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3427 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3428 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3429 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3430 Py_DECREF(ao);
3431 }
3432 wxPyEndBlockThreads(blocked);
3433 if (! found)
3434 wxGridCellEditor::Show(show, attr);
3435 }
3436
3437
3438 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3439 bool found;
3440 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3441 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3442 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3443 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3444
3445 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3446
3447 Py_DECREF(ro);
3448 Py_DECREF(ao);
3449 }
3450 wxPyEndBlockThreads(blocked);
3451 if (! found)
3452 wxGridCellEditor::PaintBackground(rectCell, attr);
3453 }
3454
3455
3456 DEC_PYCALLBACK___pure(Reset);
3457 DEC_PYCALLBACK__constany(SetSize, wxRect);
3458 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3459 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3460 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3461 DEC_PYCALLBACK__(StartingClick);
3462 DEC_PYCALLBACK__(Destroy);
3463 DEC_PYCALLBACK__STRING(SetParameters);
3464 DEC_PYCALLBACK_STRING__constpure(GetValue);
3465
3466 PYPRIVATE;
3467 };
3468
3469
3470 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3471 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3472 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3473 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3474 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3475 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3476 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3477 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3478 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3479
3480
3481 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3482 if (!self->GetClientObject())
3483 self->SetClientObject(new wxPyOORClientData(_self));
3484 }
3485 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3486 }
3487 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3488 if (!self->GetClientObject())
3489 self->SetClientObject(new wxPyOORClientData(_self));
3490 }
3491
3492 SWIGINTERN int
3493 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3494 {
3495 long v = 0;
3496 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3497 return SWIG_TypeError;
3498 }
3499 else if (val)
3500 *val = (unsigned long)v;
3501 return SWIG_OK;
3502 }
3503
3504
3505 SWIGINTERNINLINE int
3506 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3507 {
3508 unsigned long v;
3509 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3510 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3511 return res;
3512 }
3513
3514
3515 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3516 {
3517 public:
3518 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3519
3520 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3521 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3522 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3523 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3524
3525 PYPRIVATE;
3526 };
3527
3528 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3529 if (!self->GetClientObject())
3530 self->SetClientObject(new wxPyOORClientData(_self));
3531 }
3532
3533 #define SWIG_From_double PyFloat_FromDouble
3534
3535
3536 SWIGINTERN int
3537 SWIG_AsVal_double (PyObject *obj, double* val)
3538 {
3539 if (PyNumber_Check(obj)) {
3540 if (val) *val = PyFloat_AsDouble(obj);
3541 return SWIG_OK;
3542 }
3543 return SWIG_TypeError;
3544 }
3545
3546
3547 class wxPyGridTableBase : public wxGridTableBase
3548 {
3549 public:
3550 wxPyGridTableBase() : wxGridTableBase() {}
3551
3552 PYCALLBACK_INT__pure(GetNumberRows);
3553 PYCALLBACK_INT__pure(GetNumberCols);
3554 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3555 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3556 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3557 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3558 PYCALLBACK__(wxGridTableBase, Clear);
3559 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3560 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3561 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3562 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3563 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3564 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3565 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3566 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3567 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3568 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3569 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3570 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3571 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3572 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3573 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3574
3575
3576 wxString GetValue(int row, int col) {
3577 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3578 wxString rval;
3579 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3580 PyObject* ro;
3581 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3582 if (ro) {
3583 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3584 PyObject* old = ro;
3585 ro = PyObject_Str(ro);
3586 Py_DECREF(old);
3587 }
3588 rval = Py2wxString(ro);
3589 Py_DECREF(ro);
3590 }
3591 }
3592 wxPyEndBlockThreads(blocked);
3593 return rval;
3594 }
3595
3596 void SetValue(int row, int col, const wxString& val) {
3597 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3598 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3599 PyObject* s = wx2PyString(val);
3600 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3601 Py_DECREF(s);
3602 }
3603 wxPyEndBlockThreads(blocked);
3604 }
3605
3606
3607 // Map the Get/Set methods for the standard non-string types to
3608 // the GetValue and SetValue python methods.
3609 long GetValueAsLong( int row, int col ) {
3610 long rval = 0;
3611 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3612 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3613 PyObject* ro;
3614 PyObject* num;
3615 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3616 if (ro && PyNumber_Check(ro)) {
3617 num = PyNumber_Int(ro);
3618 if (num) {
3619 rval = PyInt_AsLong(num);
3620 Py_DECREF(num);
3621 }
3622 Py_DECREF(ro);
3623 }
3624 }
3625 wxPyEndBlockThreads(blocked);
3626 return rval;
3627 }
3628
3629 double GetValueAsDouble( int row, int col ) {
3630 double rval = 0.0;
3631 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3632 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3633 PyObject* ro;
3634 PyObject* num;
3635 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3636 if (ro && PyNumber_Check(ro)) {
3637 num = PyNumber_Float(ro);
3638 if (num) {
3639 rval = PyFloat_AsDouble(num);
3640 Py_DECREF(num);
3641 }
3642 Py_DECREF(ro);
3643 }
3644 }
3645 wxPyEndBlockThreads(blocked);
3646 return rval;
3647 }
3648
3649 bool GetValueAsBool( int row, int col ) {
3650 return (bool)GetValueAsLong(row, col);
3651 }
3652
3653 void SetValueAsLong( int row, int col, long value ) {
3654 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3655 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3656 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3657 }
3658 wxPyEndBlockThreads(blocked);
3659 }
3660
3661 void SetValueAsDouble( int row, int col, double value ) {
3662 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3663 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3664 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3665 }
3666 wxPyEndBlockThreads(blocked);
3667 }
3668
3669 void SetValueAsBool( int row, int col, bool value ) {
3670 SetValueAsLong( row, col, (long)value );
3671 }
3672
3673
3674 PYPRIVATE;
3675 };
3676
3677 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3678
3679 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3680
3681 if (source == Py_None) {
3682 **obj = wxGridCellCoords(-1,-1);
3683 return true;
3684 }
3685
3686 // If source is an object instance then it may already be the right type
3687 if (wxPySwigInstance_Check(source)) {
3688 wxGridCellCoords* ptr;
3689 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3690 goto error;
3691 *obj = ptr;
3692 return true;
3693 }
3694 // otherwise a 2-tuple of integers is expected
3695 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3696 PyObject* o1 = PySequence_GetItem(source, 0);
3697 PyObject* o2 = PySequence_GetItem(source, 1);
3698 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3699 Py_DECREF(o1);
3700 Py_DECREF(o2);
3701 goto error;
3702 }
3703 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3704 Py_DECREF(o1);
3705 Py_DECREF(o2);
3706 return true;
3707 }
3708
3709 error:
3710 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3711 return false;
3712 }
3713
3714
3715 bool wxGridCellCoords_typecheck(PyObject* source) {
3716 void* ptr;
3717
3718 if (wxPySwigInstance_Check(source) &&
3719 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3720 return true;
3721
3722 PyErr_Clear();
3723 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3724 return true;
3725
3726 return false;
3727 }
3728
3729
3730 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3731 {
3732 PyObject* list = PyList_New(0);
3733 size_t idx;
3734 for (idx = 0; idx < source.GetCount(); idx += 1) {
3735 wxGridCellCoords& coord = source.Item(idx);
3736 PyObject* tup = PyTuple_New(2);
3737 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3738 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3739 PyList_Append(list, tup);
3740 Py_DECREF(tup);
3741 }
3742 return list;
3743 }
3744
3745 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3746 wxGridCellCoords temp, *obj = &temp;
3747 if ( other == Py_None ) return false;
3748 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3749 PyErr_Clear();
3750 return false;
3751 }
3752 return self->operator==(*obj);
3753 }
3754 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3755 wxGridCellCoords temp, *obj = &temp;
3756 if ( other == Py_None ) return true;
3757 if ( ! wxGridCellCoords_helper(other, &obj)) {
3758 PyErr_Clear();
3759 return true;
3760 }
3761 return self->operator!=(*obj);
3762 }
3763 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3764 PyObject* tup = PyTuple_New(2);
3765 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3766 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3767 return tup;
3768 }
3769
3770 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3771
3772 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3773 wxGridCellCoords rv;
3774 self->XYToCell(x, y, rv);
3775 return rv;
3776 }
3777 #ifdef __cplusplus
3778 extern "C" {
3779 #endif
3780 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3781 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3782 return 1;
3783 }
3784
3785
3786 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3787 PyObject *pyobj = 0;
3788
3789 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3790 return pyobj;
3791 }
3792
3793
3794 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3795 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3796 return 1;
3797 }
3798
3799
3800 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3801 PyObject *pyobj = 0;
3802
3803 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3804 return pyobj;
3805 }
3806
3807
3808 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3809 PyObject *resultobj = 0;
3810 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3811 PyObject *arg2 = (PyObject *) 0 ;
3812 void *argp1 = 0 ;
3813 int res1 = 0 ;
3814 PyObject * obj0 = 0 ;
3815 PyObject * obj1 = 0 ;
3816 char * kwnames[] = {
3817 (char *) "self",(char *) "_self", NULL
3818 };
3819
3820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3822 if (!SWIG_IsOK(res1)) {
3823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3824 }
3825 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3826 arg2 = obj1;
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 wxGridCellWorker__setOORInfo(arg1,arg2);
3830 wxPyEndAllowThreads(__tstate);
3831 if (PyErr_Occurred()) SWIG_fail;
3832 }
3833 resultobj = SWIG_Py_Void();
3834 return resultobj;
3835 fail:
3836 return NULL;
3837 }
3838
3839
3840 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3841 PyObject *resultobj = 0;
3842 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3843 void *argp1 = 0 ;
3844 int res1 = 0 ;
3845 PyObject *swig_obj[1] ;
3846
3847 if (!args) SWIG_fail;
3848 swig_obj[0] = args;
3849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3850 if (!SWIG_IsOK(res1)) {
3851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3852 }
3853 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3854 {
3855 PyThreadState* __tstate = wxPyBeginAllowThreads();
3856 delete_wxGridCellWorker(arg1);
3857
3858 wxPyEndAllowThreads(__tstate);
3859 if (PyErr_Occurred()) SWIG_fail;
3860 }
3861 resultobj = SWIG_Py_Void();
3862 return resultobj;
3863 fail:
3864 return NULL;
3865 }
3866
3867
3868 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3869 PyObject *resultobj = 0;
3870 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3871 wxString *arg2 = 0 ;
3872 void *argp1 = 0 ;
3873 int res1 = 0 ;
3874 bool temp2 = false ;
3875 PyObject * obj0 = 0 ;
3876 PyObject * obj1 = 0 ;
3877 char * kwnames[] = {
3878 (char *) "self",(char *) "params", NULL
3879 };
3880
3881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3883 if (!SWIG_IsOK(res1)) {
3884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3885 }
3886 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3887 {
3888 arg2 = wxString_in_helper(obj1);
3889 if (arg2 == NULL) SWIG_fail;
3890 temp2 = true;
3891 }
3892 {
3893 PyThreadState* __tstate = wxPyBeginAllowThreads();
3894 (arg1)->SetParameters((wxString const &)*arg2);
3895 wxPyEndAllowThreads(__tstate);
3896 if (PyErr_Occurred()) SWIG_fail;
3897 }
3898 resultobj = SWIG_Py_Void();
3899 {
3900 if (temp2)
3901 delete arg2;
3902 }
3903 return resultobj;
3904 fail:
3905 {
3906 if (temp2)
3907 delete arg2;
3908 }
3909 return NULL;
3910 }
3911
3912
3913 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3914 PyObject *resultobj = 0;
3915 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3916 void *argp1 = 0 ;
3917 int res1 = 0 ;
3918 PyObject *swig_obj[1] ;
3919
3920 if (!args) SWIG_fail;
3921 swig_obj[0] = args;
3922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3923 if (!SWIG_IsOK(res1)) {
3924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3925 }
3926 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3927 {
3928 PyThreadState* __tstate = wxPyBeginAllowThreads();
3929 (arg1)->IncRef();
3930 wxPyEndAllowThreads(__tstate);
3931 if (PyErr_Occurred()) SWIG_fail;
3932 }
3933 resultobj = SWIG_Py_Void();
3934 return resultobj;
3935 fail:
3936 return NULL;
3937 }
3938
3939
3940 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3941 PyObject *resultobj = 0;
3942 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3943 void *argp1 = 0 ;
3944 int res1 = 0 ;
3945 PyObject *swig_obj[1] ;
3946
3947 if (!args) SWIG_fail;
3948 swig_obj[0] = args;
3949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3950 if (!SWIG_IsOK(res1)) {
3951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3952 }
3953 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3954 {
3955 PyThreadState* __tstate = wxPyBeginAllowThreads();
3956 (arg1)->DecRef();
3957 wxPyEndAllowThreads(__tstate);
3958 if (PyErr_Occurred()) SWIG_fail;
3959 }
3960 resultobj = SWIG_Py_Void();
3961 return resultobj;
3962 fail:
3963 return NULL;
3964 }
3965
3966
3967 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3968 PyObject *obj;
3969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3970 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3971 return SWIG_Py_Void();
3972 }
3973
3974 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3975 PyObject *obj;
3976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3977 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
3978 return SWIG_Py_Void();
3979 }
3980
3981 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3982 PyObject *resultobj = 0;
3983 wxPyGridCellRenderer *result = 0 ;
3984
3985 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
3986 {
3987 PyThreadState* __tstate = wxPyBeginAllowThreads();
3988 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3989 wxPyEndAllowThreads(__tstate);
3990 if (PyErr_Occurred()) SWIG_fail;
3991 }
3992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
3993 return resultobj;
3994 fail:
3995 return NULL;
3996 }
3997
3998
3999 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4000 PyObject *resultobj = 0;
4001 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4002 PyObject *arg2 = (PyObject *) 0 ;
4003 PyObject *arg3 = (PyObject *) 0 ;
4004 void *argp1 = 0 ;
4005 int res1 = 0 ;
4006 PyObject * obj0 = 0 ;
4007 PyObject * obj1 = 0 ;
4008 PyObject * obj2 = 0 ;
4009 char * kwnames[] = {
4010 (char *) "self",(char *) "self",(char *) "_class", NULL
4011 };
4012
4013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4015 if (!SWIG_IsOK(res1)) {
4016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4017 }
4018 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4019 arg2 = obj1;
4020 arg3 = obj2;
4021 {
4022 PyThreadState* __tstate = wxPyBeginAllowThreads();
4023 (arg1)->_setCallbackInfo(arg2,arg3);
4024 wxPyEndAllowThreads(__tstate);
4025 if (PyErr_Occurred()) SWIG_fail;
4026 }
4027 resultobj = SWIG_Py_Void();
4028 return resultobj;
4029 fail:
4030 return NULL;
4031 }
4032
4033
4034 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4035 PyObject *resultobj = 0;
4036 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4037 wxString *arg2 = 0 ;
4038 void *argp1 = 0 ;
4039 int res1 = 0 ;
4040 bool temp2 = false ;
4041 PyObject * obj0 = 0 ;
4042 PyObject * obj1 = 0 ;
4043 char * kwnames[] = {
4044 (char *) "self",(char *) "params", NULL
4045 };
4046
4047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4049 if (!SWIG_IsOK(res1)) {
4050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4051 }
4052 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4053 {
4054 arg2 = wxString_in_helper(obj1);
4055 if (arg2 == NULL) SWIG_fail;
4056 temp2 = true;
4057 }
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 (arg1)->SetParameters((wxString const &)*arg2);
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 resultobj = SWIG_Py_Void();
4065 {
4066 if (temp2)
4067 delete arg2;
4068 }
4069 return resultobj;
4070 fail:
4071 {
4072 if (temp2)
4073 delete arg2;
4074 }
4075 return NULL;
4076 }
4077
4078
4079 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4080 PyObject *obj;
4081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4082 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4083 return SWIG_Py_Void();
4084 }
4085
4086 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4087 return SWIG_Python_InitShadowInstance(args);
4088 }
4089
4090 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4091 PyObject *resultobj = 0;
4092 wxGridCellStringRenderer *result = 0 ;
4093
4094 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4095 {
4096 PyThreadState* __tstate = wxPyBeginAllowThreads();
4097 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4098 wxPyEndAllowThreads(__tstate);
4099 if (PyErr_Occurred()) SWIG_fail;
4100 }
4101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4102 return resultobj;
4103 fail:
4104 return NULL;
4105 }
4106
4107
4108 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4109 PyObject *obj;
4110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4111 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4112 return SWIG_Py_Void();
4113 }
4114
4115 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4116 return SWIG_Python_InitShadowInstance(args);
4117 }
4118
4119 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4120 PyObject *resultobj = 0;
4121 wxGridCellNumberRenderer *result = 0 ;
4122
4123 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4124 {
4125 PyThreadState* __tstate = wxPyBeginAllowThreads();
4126 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4127 wxPyEndAllowThreads(__tstate);
4128 if (PyErr_Occurred()) SWIG_fail;
4129 }
4130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4131 return resultobj;
4132 fail:
4133 return NULL;
4134 }
4135
4136
4137 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4138 PyObject *obj;
4139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4140 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4141 return SWIG_Py_Void();
4142 }
4143
4144 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4145 return SWIG_Python_InitShadowInstance(args);
4146 }
4147
4148 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj = 0;
4150 int arg1 = (int) -1 ;
4151 int arg2 = (int) -1 ;
4152 wxGridCellFloatRenderer *result = 0 ;
4153 int val1 ;
4154 int ecode1 = 0 ;
4155 int val2 ;
4156 int ecode2 = 0 ;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 char * kwnames[] = {
4160 (char *) "width",(char *) "precision", NULL
4161 };
4162
4163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4164 if (obj0) {
4165 ecode1 = SWIG_AsVal_int(obj0, &val1);
4166 if (!SWIG_IsOK(ecode1)) {
4167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4168 }
4169 arg1 = static_cast< int >(val1);
4170 }
4171 if (obj1) {
4172 ecode2 = SWIG_AsVal_int(obj1, &val2);
4173 if (!SWIG_IsOK(ecode2)) {
4174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4175 }
4176 arg2 = static_cast< int >(val2);
4177 }
4178 {
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4192 PyObject *resultobj = 0;
4193 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4194 int result;
4195 void *argp1 = 0 ;
4196 int res1 = 0 ;
4197 PyObject *swig_obj[1] ;
4198
4199 if (!args) SWIG_fail;
4200 swig_obj[0] = args;
4201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4202 if (!SWIG_IsOK(res1)) {
4203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4204 }
4205 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 resultobj = SWIG_From_int(static_cast< int >(result));
4213 return resultobj;
4214 fail:
4215 return NULL;
4216 }
4217
4218
4219 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4220 PyObject *resultobj = 0;
4221 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4222 int arg2 ;
4223 void *argp1 = 0 ;
4224 int res1 = 0 ;
4225 int val2 ;
4226 int ecode2 = 0 ;
4227 PyObject * obj0 = 0 ;
4228 PyObject * obj1 = 0 ;
4229 char * kwnames[] = {
4230 (char *) "self",(char *) "width", NULL
4231 };
4232
4233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4235 if (!SWIG_IsOK(res1)) {
4236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4237 }
4238 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4239 ecode2 = SWIG_AsVal_int(obj1, &val2);
4240 if (!SWIG_IsOK(ecode2)) {
4241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4242 }
4243 arg2 = static_cast< int >(val2);
4244 {
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 (arg1)->SetWidth(arg2);
4247 wxPyEndAllowThreads(__tstate);
4248 if (PyErr_Occurred()) SWIG_fail;
4249 }
4250 resultobj = SWIG_Py_Void();
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4258 PyObject *resultobj = 0;
4259 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4260 int result;
4261 void *argp1 = 0 ;
4262 int res1 = 0 ;
4263 PyObject *swig_obj[1] ;
4264
4265 if (!args) SWIG_fail;
4266 swig_obj[0] = args;
4267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4268 if (!SWIG_IsOK(res1)) {
4269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4270 }
4271 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4272 {
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4275 wxPyEndAllowThreads(__tstate);
4276 if (PyErr_Occurred()) SWIG_fail;
4277 }
4278 resultobj = SWIG_From_int(static_cast< int >(result));
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4286 PyObject *resultobj = 0;
4287 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4288 int arg2 ;
4289 void *argp1 = 0 ;
4290 int res1 = 0 ;
4291 int val2 ;
4292 int ecode2 = 0 ;
4293 PyObject * obj0 = 0 ;
4294 PyObject * obj1 = 0 ;
4295 char * kwnames[] = {
4296 (char *) "self",(char *) "precision", NULL
4297 };
4298
4299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4301 if (!SWIG_IsOK(res1)) {
4302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4303 }
4304 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4305 ecode2 = SWIG_AsVal_int(obj1, &val2);
4306 if (!SWIG_IsOK(ecode2)) {
4307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4308 }
4309 arg2 = static_cast< int >(val2);
4310 {
4311 PyThreadState* __tstate = wxPyBeginAllowThreads();
4312 (arg1)->SetPrecision(arg2);
4313 wxPyEndAllowThreads(__tstate);
4314 if (PyErr_Occurred()) SWIG_fail;
4315 }
4316 resultobj = SWIG_Py_Void();
4317 return resultobj;
4318 fail:
4319 return NULL;
4320 }
4321
4322
4323 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4324 PyObject *obj;
4325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4326 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4327 return SWIG_Py_Void();
4328 }
4329
4330 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331 return SWIG_Python_InitShadowInstance(args);
4332 }
4333
4334 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4335 PyObject *resultobj = 0;
4336 wxGridCellBoolRenderer *result = 0 ;
4337
4338 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4339 {
4340 PyThreadState* __tstate = wxPyBeginAllowThreads();
4341 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4342 wxPyEndAllowThreads(__tstate);
4343 if (PyErr_Occurred()) SWIG_fail;
4344 }
4345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4346 return resultobj;
4347 fail:
4348 return NULL;
4349 }
4350
4351
4352 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4353 PyObject *obj;
4354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4355 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4356 return SWIG_Py_Void();
4357 }
4358
4359 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4360 return SWIG_Python_InitShadowInstance(args);
4361 }
4362
4363 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj = 0;
4365 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4366 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4367 wxGridCellDateTimeRenderer *result = 0 ;
4368 PyObject * obj0 = 0 ;
4369 PyObject * obj1 = 0 ;
4370 char * kwnames[] = {
4371 (char *) "outformat",(char *) "informat", NULL
4372 };
4373
4374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4375 if (obj0) {
4376 {
4377 wxString* sptr = wxString_in_helper(obj0);
4378 if (sptr == NULL) SWIG_fail;
4379 arg1 = *sptr;
4380 delete sptr;
4381 }
4382 }
4383 if (obj1) {
4384 {
4385 wxString* sptr = wxString_in_helper(obj1);
4386 if (sptr == NULL) SWIG_fail;
4387 arg2 = *sptr;
4388 delete sptr;
4389 }
4390 }
4391 {
4392 PyThreadState* __tstate = wxPyBeginAllowThreads();
4393 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4394 wxPyEndAllowThreads(__tstate);
4395 if (PyErr_Occurred()) SWIG_fail;
4396 }
4397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4398 return resultobj;
4399 fail:
4400 return NULL;
4401 }
4402
4403
4404 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4405 PyObject *obj;
4406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4407 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4408 return SWIG_Py_Void();
4409 }
4410
4411 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4412 return SWIG_Python_InitShadowInstance(args);
4413 }
4414
4415 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4416 PyObject *resultobj = 0;
4417 wxString const &arg1_defvalue = wxPyEmptyString ;
4418 wxString *arg1 = (wxString *) &arg1_defvalue ;
4419 wxGridCellEnumRenderer *result = 0 ;
4420 bool temp1 = false ;
4421 PyObject * obj0 = 0 ;
4422 char * kwnames[] = {
4423 (char *) "choices", NULL
4424 };
4425
4426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4427 if (obj0) {
4428 {
4429 arg1 = wxString_in_helper(obj0);
4430 if (arg1 == NULL) SWIG_fail;
4431 temp1 = true;
4432 }
4433 }
4434 {
4435 PyThreadState* __tstate = wxPyBeginAllowThreads();
4436 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4441 {
4442 if (temp1)
4443 delete arg1;
4444 }
4445 return resultobj;
4446 fail:
4447 {
4448 if (temp1)
4449 delete arg1;
4450 }
4451 return NULL;
4452 }
4453
4454
4455 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4456 PyObject *obj;
4457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4458 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4459 return SWIG_Py_Void();
4460 }
4461
4462 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4463 return SWIG_Python_InitShadowInstance(args);
4464 }
4465
4466 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4467 PyObject *resultobj = 0;
4468 wxGridCellAutoWrapStringRenderer *result = 0 ;
4469
4470 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4471 {
4472 PyThreadState* __tstate = wxPyBeginAllowThreads();
4473 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4474 wxPyEndAllowThreads(__tstate);
4475 if (PyErr_Occurred()) SWIG_fail;
4476 }
4477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4478 return resultobj;
4479 fail:
4480 return NULL;
4481 }
4482
4483
4484 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4485 PyObject *obj;
4486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4487 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4488 return SWIG_Py_Void();
4489 }
4490
4491 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 return SWIG_Python_InitShadowInstance(args);
4493 }
4494
4495 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4496 PyObject *resultobj = 0;
4497 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4498 bool result;
4499 void *argp1 = 0 ;
4500 int res1 = 0 ;
4501 PyObject *swig_obj[1] ;
4502
4503 if (!args) SWIG_fail;
4504 swig_obj[0] = args;
4505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4508 }
4509 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4510 {
4511 PyThreadState* __tstate = wxPyBeginAllowThreads();
4512 result = (bool)(arg1)->IsCreated();
4513 wxPyEndAllowThreads(__tstate);
4514 if (PyErr_Occurred()) SWIG_fail;
4515 }
4516 {
4517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4518 }
4519 return resultobj;
4520 fail:
4521 return NULL;
4522 }
4523
4524
4525 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4526 PyObject *resultobj = 0;
4527 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4528 wxControl *result = 0 ;
4529 void *argp1 = 0 ;
4530 int res1 = 0 ;
4531 PyObject *swig_obj[1] ;
4532
4533 if (!args) SWIG_fail;
4534 swig_obj[0] = args;
4535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4536 if (!SWIG_IsOK(res1)) {
4537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4538 }
4539 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4540 {
4541 PyThreadState* __tstate = wxPyBeginAllowThreads();
4542 result = (wxControl *)(arg1)->GetControl();
4543 wxPyEndAllowThreads(__tstate);
4544 if (PyErr_Occurred()) SWIG_fail;
4545 }
4546 {
4547 resultobj = wxPyMake_wxObject(result, 0);
4548 }
4549 return resultobj;
4550 fail:
4551 return NULL;
4552 }
4553
4554
4555 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4556 PyObject *resultobj = 0;
4557 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4558 wxControl *arg2 = (wxControl *) 0 ;
4559 void *argp1 = 0 ;
4560 int res1 = 0 ;
4561 void *argp2 = 0 ;
4562 int res2 = 0 ;
4563 PyObject * obj0 = 0 ;
4564 PyObject * obj1 = 0 ;
4565 char * kwnames[] = {
4566 (char *) "self",(char *) "control", NULL
4567 };
4568
4569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4571 if (!SWIG_IsOK(res1)) {
4572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4573 }
4574 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4576 if (!SWIG_IsOK(res2)) {
4577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4578 }
4579 arg2 = reinterpret_cast< wxControl * >(argp2);
4580 {
4581 PyThreadState* __tstate = wxPyBeginAllowThreads();
4582 (arg1)->SetControl(arg2);
4583 wxPyEndAllowThreads(__tstate);
4584 if (PyErr_Occurred()) SWIG_fail;
4585 }
4586 resultobj = SWIG_Py_Void();
4587 return resultobj;
4588 fail:
4589 return NULL;
4590 }
4591
4592
4593 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4594 PyObject *resultobj = 0;
4595 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4596 wxGridCellAttr *result = 0 ;
4597 void *argp1 = 0 ;
4598 int res1 = 0 ;
4599 PyObject *swig_obj[1] ;
4600
4601 if (!args) SWIG_fail;
4602 swig_obj[0] = args;
4603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4604 if (!SWIG_IsOK(res1)) {
4605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4606 }
4607 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4608 {
4609 PyThreadState* __tstate = wxPyBeginAllowThreads();
4610 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4611 wxPyEndAllowThreads(__tstate);
4612 if (PyErr_Occurred()) SWIG_fail;
4613 }
4614 {
4615 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4616 }
4617 return resultobj;
4618 fail:
4619 return NULL;
4620 }
4621
4622
4623 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4624 PyObject *resultobj = 0;
4625 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4626 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4627 void *argp1 = 0 ;
4628 int res1 = 0 ;
4629 void *argp2 = 0 ;
4630 int res2 = 0 ;
4631 PyObject * obj0 = 0 ;
4632 PyObject * obj1 = 0 ;
4633 char * kwnames[] = {
4634 (char *) "self",(char *) "attr", NULL
4635 };
4636
4637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4641 }
4642 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4643 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4644 if (!SWIG_IsOK(res2)) {
4645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4646 }
4647 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4648 {
4649 PyThreadState* __tstate = wxPyBeginAllowThreads();
4650 (arg1)->SetCellAttr(arg2);
4651 wxPyEndAllowThreads(__tstate);
4652 if (PyErr_Occurred()) SWIG_fail;
4653 }
4654 resultobj = SWIG_Py_Void();
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj = 0;
4663 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4664 wxWindow *arg2 = (wxWindow *) 0 ;
4665 int arg3 ;
4666 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4667 void *argp1 = 0 ;
4668 int res1 = 0 ;
4669 void *argp2 = 0 ;
4670 int res2 = 0 ;
4671 int val3 ;
4672 int ecode3 = 0 ;
4673 void *argp4 = 0 ;
4674 int res4 = 0 ;
4675 PyObject * obj0 = 0 ;
4676 PyObject * obj1 = 0 ;
4677 PyObject * obj2 = 0 ;
4678 PyObject * obj3 = 0 ;
4679 char * kwnames[] = {
4680 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4681 };
4682
4683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4685 if (!SWIG_IsOK(res1)) {
4686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4687 }
4688 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4690 if (!SWIG_IsOK(res2)) {
4691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4692 }
4693 arg2 = reinterpret_cast< wxWindow * >(argp2);
4694 ecode3 = SWIG_AsVal_int(obj2, &val3);
4695 if (!SWIG_IsOK(ecode3)) {
4696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4697 }
4698 arg3 = static_cast< int >(val3);
4699 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4700 if (!SWIG_IsOK(res4)) {
4701 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4702 }
4703 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4704 {
4705 PyThreadState* __tstate = wxPyBeginAllowThreads();
4706 (arg1)->Create(arg2,arg3,arg4);
4707 wxPyEndAllowThreads(__tstate);
4708 if (PyErr_Occurred()) SWIG_fail;
4709 }
4710 resultobj = SWIG_Py_Void();
4711 return resultobj;
4712 fail:
4713 return NULL;
4714 }
4715
4716
4717 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4718 PyObject *resultobj = 0;
4719 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4720 int arg2 ;
4721 int arg3 ;
4722 wxGrid *arg4 = (wxGrid *) 0 ;
4723 void *argp1 = 0 ;
4724 int res1 = 0 ;
4725 int val2 ;
4726 int ecode2 = 0 ;
4727 int val3 ;
4728 int ecode3 = 0 ;
4729 void *argp4 = 0 ;
4730 int res4 = 0 ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 PyObject * obj2 = 0 ;
4734 PyObject * obj3 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4743 }
4744 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4745 ecode2 = SWIG_AsVal_int(obj1, &val2);
4746 if (!SWIG_IsOK(ecode2)) {
4747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4748 }
4749 arg2 = static_cast< int >(val2);
4750 ecode3 = SWIG_AsVal_int(obj2, &val3);
4751 if (!SWIG_IsOK(ecode3)) {
4752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4753 }
4754 arg3 = static_cast< int >(val3);
4755 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4756 if (!SWIG_IsOK(res4)) {
4757 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4758 }
4759 arg4 = reinterpret_cast< wxGrid * >(argp4);
4760 {
4761 PyThreadState* __tstate = wxPyBeginAllowThreads();
4762 (arg1)->BeginEdit(arg2,arg3,arg4);
4763 wxPyEndAllowThreads(__tstate);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 resultobj = SWIG_Py_Void();
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj = 0;
4775 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4776 int arg2 ;
4777 int arg3 ;
4778 wxGrid *arg4 = (wxGrid *) 0 ;
4779 bool result;
4780 void *argp1 = 0 ;
4781 int res1 = 0 ;
4782 int val2 ;
4783 int ecode2 = 0 ;
4784 int val3 ;
4785 int ecode3 = 0 ;
4786 void *argp4 = 0 ;
4787 int res4 = 0 ;
4788 PyObject * obj0 = 0 ;
4789 PyObject * obj1 = 0 ;
4790 PyObject * obj2 = 0 ;
4791 PyObject * obj3 = 0 ;
4792 char * kwnames[] = {
4793 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4794 };
4795
4796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4798 if (!SWIG_IsOK(res1)) {
4799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4800 }
4801 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4802 ecode2 = SWIG_AsVal_int(obj1, &val2);
4803 if (!SWIG_IsOK(ecode2)) {
4804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
4805 }
4806 arg2 = static_cast< int >(val2);
4807 ecode3 = SWIG_AsVal_int(obj2, &val3);
4808 if (!SWIG_IsOK(ecode3)) {
4809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
4810 }
4811 arg3 = static_cast< int >(val3);
4812 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4813 if (!SWIG_IsOK(res4)) {
4814 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4815 }
4816 arg4 = reinterpret_cast< wxGrid * >(argp4);
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 {
4824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4825 }
4826 return resultobj;
4827 fail:
4828 return NULL;
4829 }
4830
4831
4832 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4833 PyObject *resultobj = 0;
4834 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4835 void *argp1 = 0 ;
4836 int res1 = 0 ;
4837 PyObject *swig_obj[1] ;
4838
4839 if (!args) SWIG_fail;
4840 swig_obj[0] = args;
4841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4842 if (!SWIG_IsOK(res1)) {
4843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4844 }
4845 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4846 {
4847 PyThreadState* __tstate = wxPyBeginAllowThreads();
4848 (arg1)->Reset();
4849 wxPyEndAllowThreads(__tstate);
4850 if (PyErr_Occurred()) SWIG_fail;
4851 }
4852 resultobj = SWIG_Py_Void();
4853 return resultobj;
4854 fail:
4855 return NULL;
4856 }
4857
4858
4859 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4860 PyObject *resultobj = 0;
4861 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4862 wxGridCellEditor *result = 0 ;
4863 void *argp1 = 0 ;
4864 int res1 = 0 ;
4865 PyObject *swig_obj[1] ;
4866
4867 if (!args) SWIG_fail;
4868 swig_obj[0] = args;
4869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4870 if (!SWIG_IsOK(res1)) {
4871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
4872 }
4873 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4874 {
4875 PyThreadState* __tstate = wxPyBeginAllowThreads();
4876 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4877 wxPyEndAllowThreads(__tstate);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 {
4881 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4882 }
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj = 0;
4891 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4892 wxRect *arg2 = 0 ;
4893 void *argp1 = 0 ;
4894 int res1 = 0 ;
4895 wxRect temp2 ;
4896 PyObject * obj0 = 0 ;
4897 PyObject * obj1 = 0 ;
4898 char * kwnames[] = {
4899 (char *) "self",(char *) "rect", NULL
4900 };
4901
4902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
4903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4904 if (!SWIG_IsOK(res1)) {
4905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4906 }
4907 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4908 {
4909 arg2 = &temp2;
4910 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4911 }
4912 {
4913 PyThreadState* __tstate = wxPyBeginAllowThreads();
4914 (arg1)->SetSize((wxRect const &)*arg2);
4915 wxPyEndAllowThreads(__tstate);
4916 if (PyErr_Occurred()) SWIG_fail;
4917 }
4918 resultobj = SWIG_Py_Void();
4919 return resultobj;
4920 fail:
4921 return NULL;
4922 }
4923
4924
4925 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4926 PyObject *resultobj = 0;
4927 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4928 bool arg2 ;
4929 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4930 void *argp1 = 0 ;
4931 int res1 = 0 ;
4932 bool val2 ;
4933 int ecode2 = 0 ;
4934 void *argp3 = 0 ;
4935 int res3 = 0 ;
4936 PyObject * obj0 = 0 ;
4937 PyObject * obj1 = 0 ;
4938 PyObject * obj2 = 0 ;
4939 char * kwnames[] = {
4940 (char *) "self",(char *) "show",(char *) "attr", NULL
4941 };
4942
4943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4945 if (!SWIG_IsOK(res1)) {
4946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4947 }
4948 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4950 if (!SWIG_IsOK(ecode2)) {
4951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
4952 }
4953 arg2 = static_cast< bool >(val2);
4954 if (obj2) {
4955 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4956 if (!SWIG_IsOK(res3)) {
4957 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4958 }
4959 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4960 }
4961 {
4962 PyThreadState* __tstate = wxPyBeginAllowThreads();
4963 (arg1)->Show(arg2,arg3);
4964 wxPyEndAllowThreads(__tstate);
4965 if (PyErr_Occurred()) SWIG_fail;
4966 }
4967 resultobj = SWIG_Py_Void();
4968 return resultobj;
4969 fail:
4970 return NULL;
4971 }
4972
4973
4974 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4975 PyObject *resultobj = 0;
4976 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4977 wxRect *arg2 = 0 ;
4978 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4979 void *argp1 = 0 ;
4980 int res1 = 0 ;
4981 wxRect temp2 ;
4982 void *argp3 = 0 ;
4983 int res3 = 0 ;
4984 PyObject * obj0 = 0 ;
4985 PyObject * obj1 = 0 ;
4986 PyObject * obj2 = 0 ;
4987 char * kwnames[] = {
4988 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4989 };
4990
4991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4993 if (!SWIG_IsOK(res1)) {
4994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4995 }
4996 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4997 {
4998 arg2 = &temp2;
4999 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5000 }
5001 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5002 if (!SWIG_IsOK(res3)) {
5003 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5004 }
5005 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5006 {
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 resultobj = SWIG_Py_Void();
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5020 PyObject *resultobj = 0;
5021 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5022 wxKeyEvent *arg2 = 0 ;
5023 bool result;
5024 void *argp1 = 0 ;
5025 int res1 = 0 ;
5026 void *argp2 = 0 ;
5027 int res2 = 0 ;
5028 PyObject * obj0 = 0 ;
5029 PyObject * obj1 = 0 ;
5030 char * kwnames[] = {
5031 (char *) "self",(char *) "event", NULL
5032 };
5033
5034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5036 if (!SWIG_IsOK(res1)) {
5037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5038 }
5039 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5040 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5041 if (!SWIG_IsOK(res2)) {
5042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5043 }
5044 if (!argp2) {
5045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5046 }
5047 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5048 {
5049 PyThreadState* __tstate = wxPyBeginAllowThreads();
5050 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5051 wxPyEndAllowThreads(__tstate);
5052 if (PyErr_Occurred()) SWIG_fail;
5053 }
5054 {
5055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5056 }
5057 return resultobj;
5058 fail:
5059 return NULL;
5060 }
5061
5062
5063 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5064 PyObject *resultobj = 0;
5065 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5066 wxKeyEvent *arg2 = 0 ;
5067 void *argp1 = 0 ;
5068 int res1 = 0 ;
5069 void *argp2 = 0 ;
5070 int res2 = 0 ;
5071 PyObject * obj0 = 0 ;
5072 PyObject * obj1 = 0 ;
5073 char * kwnames[] = {
5074 (char *) "self",(char *) "event", NULL
5075 };
5076
5077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5081 }
5082 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5083 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5084 if (!SWIG_IsOK(res2)) {
5085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5086 }
5087 if (!argp2) {
5088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5089 }
5090 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 (arg1)->StartingKey(*arg2);
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 resultobj = SWIG_Py_Void();
5098 return resultobj;
5099 fail:
5100 return NULL;
5101 }
5102
5103
5104 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5105 PyObject *resultobj = 0;
5106 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5107 void *argp1 = 0 ;
5108 int res1 = 0 ;
5109 PyObject *swig_obj[1] ;
5110
5111 if (!args) SWIG_fail;
5112 swig_obj[0] = args;
5113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5114 if (!SWIG_IsOK(res1)) {
5115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5116 }
5117 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5118 {
5119 PyThreadState* __tstate = wxPyBeginAllowThreads();
5120 (arg1)->StartingClick();
5121 wxPyEndAllowThreads(__tstate);
5122 if (PyErr_Occurred()) SWIG_fail;
5123 }
5124 resultobj = SWIG_Py_Void();
5125 return resultobj;
5126 fail:
5127 return NULL;
5128 }
5129
5130
5131 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5132 PyObject *resultobj = 0;
5133 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5134 wxKeyEvent *arg2 = 0 ;
5135 void *argp1 = 0 ;
5136 int res1 = 0 ;
5137 void *argp2 = 0 ;
5138 int res2 = 0 ;
5139 PyObject * obj0 = 0 ;
5140 PyObject * obj1 = 0 ;
5141 char * kwnames[] = {
5142 (char *) "self",(char *) "event", NULL
5143 };
5144
5145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5147 if (!SWIG_IsOK(res1)) {
5148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5149 }
5150 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5152 if (!SWIG_IsOK(res2)) {
5153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5154 }
5155 if (!argp2) {
5156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5157 }
5158 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5159 {
5160 PyThreadState* __tstate = wxPyBeginAllowThreads();
5161 (arg1)->HandleReturn(*arg2);
5162 wxPyEndAllowThreads(__tstate);
5163 if (PyErr_Occurred()) SWIG_fail;
5164 }
5165 resultobj = SWIG_Py_Void();
5166 return resultobj;
5167 fail:
5168 return NULL;
5169 }
5170
5171
5172 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5173 PyObject *resultobj = 0;
5174 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5175 void *argp1 = 0 ;
5176 int res1 = 0 ;
5177 PyObject *swig_obj[1] ;
5178
5179 if (!args) SWIG_fail;
5180 swig_obj[0] = args;
5181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5182 if (!SWIG_IsOK(res1)) {
5183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5184 }
5185 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 (arg1)->Destroy();
5189 wxPyEndAllowThreads(__tstate);
5190 if (PyErr_Occurred()) SWIG_fail;
5191 }
5192 resultobj = SWIG_Py_Void();
5193 return resultobj;
5194 fail:
5195 return NULL;
5196 }
5197
5198
5199 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5200 PyObject *obj;
5201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5202 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5203 return SWIG_Py_Void();
5204 }
5205
5206 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5207 PyObject *resultobj = 0;
5208 wxPyGridCellEditor *result = 0 ;
5209
5210 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5211 {
5212 PyThreadState* __tstate = wxPyBeginAllowThreads();
5213 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5214 wxPyEndAllowThreads(__tstate);
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5227 PyObject *arg2 = (PyObject *) 0 ;
5228 PyObject *arg3 = (PyObject *) 0 ;
5229 void *argp1 = 0 ;
5230 int res1 = 0 ;
5231 PyObject * obj0 = 0 ;
5232 PyObject * obj1 = 0 ;
5233 PyObject * obj2 = 0 ;
5234 char * kwnames[] = {
5235 (char *) "self",(char *) "self",(char *) "_class", NULL
5236 };
5237
5238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5240 if (!SWIG_IsOK(res1)) {
5241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5242 }
5243 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5244 arg2 = obj1;
5245 arg3 = obj2;
5246 {
5247 PyThreadState* __tstate = wxPyBeginAllowThreads();
5248 (arg1)->_setCallbackInfo(arg2,arg3);
5249 wxPyEndAllowThreads(__tstate);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 resultobj = SWIG_Py_Void();
5253 return resultobj;
5254 fail:
5255 return NULL;
5256 }
5257
5258
5259 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5260 PyObject *resultobj = 0;
5261 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5262 wxString *arg2 = 0 ;
5263 void *argp1 = 0 ;
5264 int res1 = 0 ;
5265 bool temp2 = false ;
5266 PyObject * obj0 = 0 ;
5267 PyObject * obj1 = 0 ;
5268 char * kwnames[] = {
5269 (char *) "self",(char *) "params", NULL
5270 };
5271
5272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5274 if (!SWIG_IsOK(res1)) {
5275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5276 }
5277 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5278 {
5279 arg2 = wxString_in_helper(obj1);
5280 if (arg2 == NULL) SWIG_fail;
5281 temp2 = true;
5282 }
5283 {
5284 PyThreadState* __tstate = wxPyBeginAllowThreads();
5285 (arg1)->SetParameters((wxString const &)*arg2);
5286 wxPyEndAllowThreads(__tstate);
5287 if (PyErr_Occurred()) SWIG_fail;
5288 }
5289 resultobj = SWIG_Py_Void();
5290 {
5291 if (temp2)
5292 delete arg2;
5293 }
5294 return resultobj;
5295 fail:
5296 {
5297 if (temp2)
5298 delete arg2;
5299 }
5300 return NULL;
5301 }
5302
5303
5304 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5305 PyObject *obj;
5306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5307 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5308 return SWIG_Py_Void();
5309 }
5310
5311 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 return SWIG_Python_InitShadowInstance(args);
5313 }
5314
5315 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5316 PyObject *resultobj = 0;
5317 wxGridCellTextEditor *result = 0 ;
5318
5319 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5320 {
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5334 PyObject *resultobj = 0;
5335 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5336 wxString result;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 PyObject *swig_obj[1] ;
5340
5341 if (!args) SWIG_fail;
5342 swig_obj[0] = args;
5343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5344 if (!SWIG_IsOK(res1)) {
5345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5346 }
5347 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 result = (arg1)->GetValue();
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 #if wxUSE_UNICODE
5356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5357 #else
5358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5359 #endif
5360 }
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5368 PyObject *obj;
5369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5370 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5371 return SWIG_Py_Void();
5372 }
5373
5374 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5375 return SWIG_Python_InitShadowInstance(args);
5376 }
5377
5378 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 int arg1 = (int) -1 ;
5381 int arg2 = (int) -1 ;
5382 wxGridCellNumberEditor *result = 0 ;
5383 int val1 ;
5384 int ecode1 = 0 ;
5385 int val2 ;
5386 int ecode2 = 0 ;
5387 PyObject * obj0 = 0 ;
5388 PyObject * obj1 = 0 ;
5389 char * kwnames[] = {
5390 (char *) "min",(char *) "max", NULL
5391 };
5392
5393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5394 if (obj0) {
5395 ecode1 = SWIG_AsVal_int(obj0, &val1);
5396 if (!SWIG_IsOK(ecode1)) {
5397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5398 }
5399 arg1 = static_cast< int >(val1);
5400 }
5401 if (obj1) {
5402 ecode2 = SWIG_AsVal_int(obj1, &val2);
5403 if (!SWIG_IsOK(ecode2)) {
5404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5405 }
5406 arg2 = static_cast< int >(val2);
5407 }
5408 {
5409 PyThreadState* __tstate = wxPyBeginAllowThreads();
5410 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5411 wxPyEndAllowThreads(__tstate);
5412 if (PyErr_Occurred()) SWIG_fail;
5413 }
5414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5415 return resultobj;
5416 fail:
5417 return NULL;
5418 }
5419
5420
5421 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5422 PyObject *obj;
5423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5424 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5425 return SWIG_Py_Void();
5426 }
5427
5428 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5429 return SWIG_Python_InitShadowInstance(args);
5430 }
5431
5432 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5433 PyObject *resultobj = 0;
5434 int arg1 = (int) -1 ;
5435 int arg2 = (int) -1 ;
5436 wxGridCellFloatEditor *result = 0 ;
5437 int val1 ;
5438 int ecode1 = 0 ;
5439 int val2 ;
5440 int ecode2 = 0 ;
5441 PyObject * obj0 = 0 ;
5442 PyObject * obj1 = 0 ;
5443 char * kwnames[] = {
5444 (char *) "width",(char *) "precision", NULL
5445 };
5446
5447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5448 if (obj0) {
5449 ecode1 = SWIG_AsVal_int(obj0, &val1);
5450 if (!SWIG_IsOK(ecode1)) {
5451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5452 }
5453 arg1 = static_cast< int >(val1);
5454 }
5455 if (obj1) {
5456 ecode2 = SWIG_AsVal_int(obj1, &val2);
5457 if (!SWIG_IsOK(ecode2)) {
5458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5459 }
5460 arg2 = static_cast< int >(val2);
5461 }
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5465 wxPyEndAllowThreads(__tstate);
5466 if (PyErr_Occurred()) SWIG_fail;
5467 }
5468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5469 return resultobj;
5470 fail:
5471 return NULL;
5472 }
5473
5474
5475 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5476 PyObject *obj;
5477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5478 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5479 return SWIG_Py_Void();
5480 }
5481
5482 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5483 return SWIG_Python_InitShadowInstance(args);
5484 }
5485
5486 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5487 PyObject *resultobj = 0;
5488 wxGridCellBoolEditor *result = 0 ;
5489
5490 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5491 {
5492 PyThreadState* __tstate = wxPyBeginAllowThreads();
5493 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5507 wxString result;
5508 void *argp1 = 0 ;
5509 int res1 = 0 ;
5510 PyObject *swig_obj[1] ;
5511
5512 if (!args) SWIG_fail;
5513 swig_obj[0] = args;
5514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5515 if (!SWIG_IsOK(res1)) {
5516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5517 }
5518 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5519 {
5520 PyThreadState* __tstate = wxPyBeginAllowThreads();
5521 result = (arg1)->GetValue();
5522 wxPyEndAllowThreads(__tstate);
5523 if (PyErr_Occurred()) SWIG_fail;
5524 }
5525 {
5526 #if wxUSE_UNICODE
5527 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5528 #else
5529 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5530 #endif
5531 }
5532 return resultobj;
5533 fail:
5534 return NULL;
5535 }
5536
5537
5538 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5539 PyObject *obj;
5540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5541 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5542 return SWIG_Py_Void();
5543 }
5544
5545 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5546 return SWIG_Python_InitShadowInstance(args);
5547 }
5548
5549 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5550 PyObject *resultobj = 0;
5551 int arg1 = (int) 0 ;
5552 wxString *arg2 = (wxString *) NULL ;
5553 bool arg3 = (bool) false ;
5554 wxGridCellChoiceEditor *result = 0 ;
5555 bool val3 ;
5556 int ecode3 = 0 ;
5557 PyObject * obj0 = 0 ;
5558 PyObject * obj1 = 0 ;
5559 char * kwnames[] = {
5560 (char *) "choices",(char *) "allowOthers", NULL
5561 };
5562
5563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5564 if (obj0) {
5565 {
5566 arg1 = PyList_Size(obj0);
5567 arg2 = wxString_LIST_helper(obj0);
5568 if (arg2 == NULL) SWIG_fail;
5569 }
5570 }
5571 if (obj1) {
5572 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5573 if (!SWIG_IsOK(ecode3)) {
5574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5575 }
5576 arg3 = static_cast< bool >(val3);
5577 }
5578 {
5579 PyThreadState* __tstate = wxPyBeginAllowThreads();
5580 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5581 wxPyEndAllowThreads(__tstate);
5582 if (PyErr_Occurred()) SWIG_fail;
5583 }
5584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5585 {
5586 if (arg2) delete [] arg2;
5587 }
5588 return resultobj;
5589 fail:
5590 {
5591 if (arg2) delete [] arg2;
5592 }
5593 return NULL;
5594 }
5595
5596
5597 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5598 PyObject *resultobj = 0;
5599 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5600 wxString result;
5601 void *argp1 = 0 ;
5602 int res1 = 0 ;
5603 PyObject *swig_obj[1] ;
5604
5605 if (!args) SWIG_fail;
5606 swig_obj[0] = args;
5607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5608 if (!SWIG_IsOK(res1)) {
5609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5610 }
5611 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5612 {
5613 PyThreadState* __tstate = wxPyBeginAllowThreads();
5614 result = (arg1)->GetValue();
5615 wxPyEndAllowThreads(__tstate);
5616 if (PyErr_Occurred()) SWIG_fail;
5617 }
5618 {
5619 #if wxUSE_UNICODE
5620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5621 #else
5622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5623 #endif
5624 }
5625 return resultobj;
5626 fail:
5627 return NULL;
5628 }
5629
5630
5631 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5632 PyObject *obj;
5633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5634 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5635 return SWIG_Py_Void();
5636 }
5637
5638 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5639 return SWIG_Python_InitShadowInstance(args);
5640 }
5641
5642 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj = 0;
5644 wxString const &arg1_defvalue = wxPyEmptyString ;
5645 wxString *arg1 = (wxString *) &arg1_defvalue ;
5646 wxGridCellEnumEditor *result = 0 ;
5647 bool temp1 = false ;
5648 PyObject * obj0 = 0 ;
5649 char * kwnames[] = {
5650 (char *) "choices", NULL
5651 };
5652
5653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5654 if (obj0) {
5655 {
5656 arg1 = wxString_in_helper(obj0);
5657 if (arg1 == NULL) SWIG_fail;
5658 temp1 = true;
5659 }
5660 }
5661 {
5662 PyThreadState* __tstate = wxPyBeginAllowThreads();
5663 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5668 {
5669 if (temp1)
5670 delete arg1;
5671 }
5672 return resultobj;
5673 fail:
5674 {
5675 if (temp1)
5676 delete arg1;
5677 }
5678 return NULL;
5679 }
5680
5681
5682 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5683 PyObject *obj;
5684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5685 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5686 return SWIG_Py_Void();
5687 }
5688
5689 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5690 return SWIG_Python_InitShadowInstance(args);
5691 }
5692
5693 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5694 PyObject *resultobj = 0;
5695 wxGridCellAutoWrapStringEditor *result = 0 ;
5696
5697 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5698 {
5699 PyThreadState* __tstate = wxPyBeginAllowThreads();
5700 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5701 wxPyEndAllowThreads(__tstate);
5702 if (PyErr_Occurred()) SWIG_fail;
5703 }
5704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5712 PyObject *obj;
5713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5714 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5715 return SWIG_Py_Void();
5716 }
5717
5718 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5719 return SWIG_Python_InitShadowInstance(args);
5720 }
5721
5722 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5723 PyObject *resultobj = 0;
5724 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5725 PyObject *arg2 = (PyObject *) 0 ;
5726 void *argp1 = 0 ;
5727 int res1 = 0 ;
5728 PyObject * obj0 = 0 ;
5729 PyObject * obj1 = 0 ;
5730 char * kwnames[] = {
5731 (char *) "self",(char *) "_self", NULL
5732 };
5733
5734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5738 }
5739 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5740 arg2 = obj1;
5741 {
5742 PyThreadState* __tstate = wxPyBeginAllowThreads();
5743 wxGridCellAttr__setOORInfo(arg1,arg2);
5744 wxPyEndAllowThreads(__tstate);
5745 if (PyErr_Occurred()) SWIG_fail;
5746 }
5747 resultobj = SWIG_Py_Void();
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5755 PyObject *resultobj = 0;
5756 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5757 wxGridCellAttr *result = 0 ;
5758 void *argp1 = 0 ;
5759 int res1 = 0 ;
5760 PyObject * obj0 = 0 ;
5761 char * kwnames[] = {
5762 (char *) "attrDefault", NULL
5763 };
5764
5765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5766 if (obj0) {
5767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5768 if (!SWIG_IsOK(res1)) {
5769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5770 }
5771 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5772 }
5773 {
5774 PyThreadState* __tstate = wxPyBeginAllowThreads();
5775 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5776 wxPyEndAllowThreads(__tstate);
5777 if (PyErr_Occurred()) SWIG_fail;
5778 }
5779 {
5780 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5781 }
5782 return resultobj;
5783 fail:
5784 return NULL;
5785 }
5786
5787
5788 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5789 PyObject *resultobj = 0;
5790 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5791 void *argp1 = 0 ;
5792 int res1 = 0 ;
5793 PyObject *swig_obj[1] ;
5794
5795 if (!args) SWIG_fail;
5796 swig_obj[0] = args;
5797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5798 if (!SWIG_IsOK(res1)) {
5799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5800 }
5801 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5802 {
5803 PyThreadState* __tstate = wxPyBeginAllowThreads();
5804 delete_wxGridCellAttr(arg1);
5805
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 resultobj = SWIG_Py_Void();
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5817 PyObject *resultobj = 0;
5818 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5819 wxGridCellAttr *result = 0 ;
5820 void *argp1 = 0 ;
5821 int res1 = 0 ;
5822 PyObject *swig_obj[1] ;
5823
5824 if (!args) SWIG_fail;
5825 swig_obj[0] = args;
5826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5827 if (!SWIG_IsOK(res1)) {
5828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5829 }
5830 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5831 {
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5839 }
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5849 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5850 void *argp1 = 0 ;
5851 int res1 = 0 ;
5852 void *argp2 = 0 ;
5853 int res2 = 0 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 char * kwnames[] = {
5857 (char *) "self",(char *) "mergefrom", NULL
5858 };
5859
5860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5862 if (!SWIG_IsOK(res1)) {
5863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5864 }
5865 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5866 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5867 if (!SWIG_IsOK(res2)) {
5868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5869 }
5870 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 (arg1)->MergeWith(arg2);
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_Py_Void();
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5885 PyObject *resultobj = 0;
5886 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5887 void *argp1 = 0 ;
5888 int res1 = 0 ;
5889 PyObject *swig_obj[1] ;
5890
5891 if (!args) SWIG_fail;
5892 swig_obj[0] = args;
5893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5894 if (!SWIG_IsOK(res1)) {
5895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5896 }
5897 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5898 {
5899 PyThreadState* __tstate = wxPyBeginAllowThreads();
5900 (arg1)->IncRef();
5901 wxPyEndAllowThreads(__tstate);
5902 if (PyErr_Occurred()) SWIG_fail;
5903 }
5904 resultobj = SWIG_Py_Void();
5905 return resultobj;
5906 fail:
5907 return NULL;
5908 }
5909
5910
5911 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5912 PyObject *resultobj = 0;
5913 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5914 void *argp1 = 0 ;
5915 int res1 = 0 ;
5916 PyObject *swig_obj[1] ;
5917
5918 if (!args) SWIG_fail;
5919 swig_obj[0] = args;
5920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5921 if (!SWIG_IsOK(res1)) {
5922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5923 }
5924 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5925 {
5926 PyThreadState* __tstate = wxPyBeginAllowThreads();
5927 (arg1)->DecRef();
5928 wxPyEndAllowThreads(__tstate);
5929 if (PyErr_Occurred()) SWIG_fail;
5930 }
5931 resultobj = SWIG_Py_Void();
5932 return resultobj;
5933 fail:
5934 return NULL;
5935 }
5936
5937
5938 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5939 PyObject *resultobj = 0;
5940 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5941 wxColour *arg2 = 0 ;
5942 void *argp1 = 0 ;
5943 int res1 = 0 ;
5944 wxColour temp2 ;
5945 PyObject * obj0 = 0 ;
5946 PyObject * obj1 = 0 ;
5947 char * kwnames[] = {
5948 (char *) "self",(char *) "colText", NULL
5949 };
5950
5951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5953 if (!SWIG_IsOK(res1)) {
5954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5955 }
5956 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5957 {
5958 arg2 = &temp2;
5959 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5960 }
5961 {
5962 PyThreadState* __tstate = wxPyBeginAllowThreads();
5963 (arg1)->SetTextColour((wxColour const &)*arg2);
5964 wxPyEndAllowThreads(__tstate);
5965 if (PyErr_Occurred()) SWIG_fail;
5966 }
5967 resultobj = SWIG_Py_Void();
5968 return resultobj;
5969 fail:
5970 return NULL;
5971 }
5972
5973
5974 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj = 0;
5976 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5977 wxColour *arg2 = 0 ;
5978 void *argp1 = 0 ;
5979 int res1 = 0 ;
5980 wxColour temp2 ;
5981 PyObject * obj0 = 0 ;
5982 PyObject * obj1 = 0 ;
5983 char * kwnames[] = {
5984 (char *) "self",(char *) "colBack", NULL
5985 };
5986
5987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5989 if (!SWIG_IsOK(res1)) {
5990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5991 }
5992 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5993 {
5994 arg2 = &temp2;
5995 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5996 }
5997 {
5998 PyThreadState* __tstate = wxPyBeginAllowThreads();
5999 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6000 wxPyEndAllowThreads(__tstate);
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 resultobj = SWIG_Py_Void();
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj = 0;
6012 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6013 wxFont *arg2 = 0 ;
6014 void *argp1 = 0 ;
6015 int res1 = 0 ;
6016 void *argp2 = 0 ;
6017 int res2 = 0 ;
6018 PyObject * obj0 = 0 ;
6019 PyObject * obj1 = 0 ;
6020 char * kwnames[] = {
6021 (char *) "self",(char *) "font", NULL
6022 };
6023
6024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6026 if (!SWIG_IsOK(res1)) {
6027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6028 }
6029 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6030 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6031 if (!SWIG_IsOK(res2)) {
6032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6033 }
6034 if (!argp2) {
6035 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6036 }
6037 arg2 = reinterpret_cast< wxFont * >(argp2);
6038 {
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 (arg1)->SetFont((wxFont const &)*arg2);
6041 wxPyEndAllowThreads(__tstate);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 resultobj = SWIG_Py_Void();
6045 return resultobj;
6046 fail:
6047 return NULL;
6048 }
6049
6050
6051 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj = 0;
6053 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6054 int arg2 ;
6055 int arg3 ;
6056 void *argp1 = 0 ;
6057 int res1 = 0 ;
6058 int val2 ;
6059 int ecode2 = 0 ;
6060 int val3 ;
6061 int ecode3 = 0 ;
6062 PyObject * obj0 = 0 ;
6063 PyObject * obj1 = 0 ;
6064 PyObject * obj2 = 0 ;
6065 char * kwnames[] = {
6066 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6067 };
6068
6069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6071 if (!SWIG_IsOK(res1)) {
6072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6073 }
6074 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6075 ecode2 = SWIG_AsVal_int(obj1, &val2);
6076 if (!SWIG_IsOK(ecode2)) {
6077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6078 }
6079 arg2 = static_cast< int >(val2);
6080 ecode3 = SWIG_AsVal_int(obj2, &val3);
6081 if (!SWIG_IsOK(ecode3)) {
6082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6083 }
6084 arg3 = static_cast< int >(val3);
6085 {
6086 PyThreadState* __tstate = wxPyBeginAllowThreads();
6087 (arg1)->SetAlignment(arg2,arg3);
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 resultobj = SWIG_Py_Void();
6092 return resultobj;
6093 fail:
6094 return NULL;
6095 }
6096
6097
6098 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6099 PyObject *resultobj = 0;
6100 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6101 int arg2 ;
6102 int arg3 ;
6103 void *argp1 = 0 ;
6104 int res1 = 0 ;
6105 int val2 ;
6106 int ecode2 = 0 ;
6107 int val3 ;
6108 int ecode3 = 0 ;
6109 PyObject * obj0 = 0 ;
6110 PyObject * obj1 = 0 ;
6111 PyObject * obj2 = 0 ;
6112 char * kwnames[] = {
6113 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6114 };
6115
6116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6118 if (!SWIG_IsOK(res1)) {
6119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6120 }
6121 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6122 ecode2 = SWIG_AsVal_int(obj1, &val2);
6123 if (!SWIG_IsOK(ecode2)) {
6124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6125 }
6126 arg2 = static_cast< int >(val2);
6127 ecode3 = SWIG_AsVal_int(obj2, &val3);
6128 if (!SWIG_IsOK(ecode3)) {
6129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6130 }
6131 arg3 = static_cast< int >(val3);
6132 {
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 (arg1)->SetSize(arg2,arg3);
6135 wxPyEndAllowThreads(__tstate);
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 resultobj = SWIG_Py_Void();
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj = 0;
6147 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6148 bool arg2 = (bool) true ;
6149 void *argp1 = 0 ;
6150 int res1 = 0 ;
6151 bool val2 ;
6152 int ecode2 = 0 ;
6153 PyObject * obj0 = 0 ;
6154 PyObject * obj1 = 0 ;
6155 char * kwnames[] = {
6156 (char *) "self",(char *) "allow", NULL
6157 };
6158
6159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6161 if (!SWIG_IsOK(res1)) {
6162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6163 }
6164 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6165 if (obj1) {
6166 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6167 if (!SWIG_IsOK(ecode2)) {
6168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6169 }
6170 arg2 = static_cast< bool >(val2);
6171 }
6172 {
6173 PyThreadState* __tstate = wxPyBeginAllowThreads();
6174 (arg1)->SetOverflow(arg2);
6175 wxPyEndAllowThreads(__tstate);
6176 if (PyErr_Occurred()) SWIG_fail;
6177 }
6178 resultobj = SWIG_Py_Void();
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj = 0;
6187 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6188 bool arg2 = (bool) true ;
6189 void *argp1 = 0 ;
6190 int res1 = 0 ;
6191 bool val2 ;
6192 int ecode2 = 0 ;
6193 PyObject * obj0 = 0 ;
6194 PyObject * obj1 = 0 ;
6195 char * kwnames[] = {
6196 (char *) "self",(char *) "isReadOnly", NULL
6197 };
6198
6199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6201 if (!SWIG_IsOK(res1)) {
6202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6203 }
6204 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6205 if (obj1) {
6206 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6207 if (!SWIG_IsOK(ecode2)) {
6208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6209 }
6210 arg2 = static_cast< bool >(val2);
6211 }
6212 {
6213 PyThreadState* __tstate = wxPyBeginAllowThreads();
6214 (arg1)->SetReadOnly(arg2);
6215 wxPyEndAllowThreads(__tstate);
6216 if (PyErr_Occurred()) SWIG_fail;
6217 }
6218 resultobj = SWIG_Py_Void();
6219 return resultobj;
6220 fail:
6221 return NULL;
6222 }
6223
6224
6225 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6226 PyObject *resultobj = 0;
6227 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6228 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6229 void *argp1 = 0 ;
6230 int res1 = 0 ;
6231 void *argp2 = 0 ;
6232 int res2 = 0 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char * kwnames[] = {
6236 (char *) "self",(char *) "renderer", NULL
6237 };
6238
6239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6241 if (!SWIG_IsOK(res1)) {
6242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6243 }
6244 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6246 if (!SWIG_IsOK(res2)) {
6247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6248 }
6249 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6250 {
6251 PyThreadState* __tstate = wxPyBeginAllowThreads();
6252 (arg1)->SetRenderer(arg2);
6253 wxPyEndAllowThreads(__tstate);
6254 if (PyErr_Occurred()) SWIG_fail;
6255 }
6256 resultobj = SWIG_Py_Void();
6257 return resultobj;
6258 fail:
6259 return NULL;
6260 }
6261
6262
6263 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6264 PyObject *resultobj = 0;
6265 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6266 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6267 void *argp1 = 0 ;
6268 int res1 = 0 ;
6269 void *argp2 = 0 ;
6270 int res2 = 0 ;
6271 PyObject * obj0 = 0 ;
6272 PyObject * obj1 = 0 ;
6273 char * kwnames[] = {
6274 (char *) "self",(char *) "editor", NULL
6275 };
6276
6277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6279 if (!SWIG_IsOK(res1)) {
6280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6281 }
6282 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6284 if (!SWIG_IsOK(res2)) {
6285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6286 }
6287 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6288 {
6289 PyThreadState* __tstate = wxPyBeginAllowThreads();
6290 (arg1)->SetEditor(arg2);
6291 wxPyEndAllowThreads(__tstate);
6292 if (PyErr_Occurred()) SWIG_fail;
6293 }
6294 resultobj = SWIG_Py_Void();
6295 return resultobj;
6296 fail:
6297 return NULL;
6298 }
6299
6300
6301 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6302 PyObject *resultobj = 0;
6303 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6304 wxGridCellAttr::wxAttrKind arg2 ;
6305 void *argp1 = 0 ;
6306 int res1 = 0 ;
6307 int val2 ;
6308 int ecode2 = 0 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 char * kwnames[] = {
6312 (char *) "self",(char *) "kind", NULL
6313 };
6314
6315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6317 if (!SWIG_IsOK(res1)) {
6318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6319 }
6320 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6321 ecode2 = SWIG_AsVal_int(obj1, &val2);
6322 if (!SWIG_IsOK(ecode2)) {
6323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6324 }
6325 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6326 {
6327 PyThreadState* __tstate = wxPyBeginAllowThreads();
6328 (arg1)->SetKind(arg2);
6329 wxPyEndAllowThreads(__tstate);
6330 if (PyErr_Occurred()) SWIG_fail;
6331 }
6332 resultobj = SWIG_Py_Void();
6333 return resultobj;
6334 fail:
6335 return NULL;
6336 }
6337
6338
6339 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6340 PyObject *resultobj = 0;
6341 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6342 bool result;
6343 void *argp1 = 0 ;
6344 int res1 = 0 ;
6345 PyObject *swig_obj[1] ;
6346
6347 if (!args) SWIG_fail;
6348 swig_obj[0] = args;
6349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6350 if (!SWIG_IsOK(res1)) {
6351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6352 }
6353 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6354 {
6355 PyThreadState* __tstate = wxPyBeginAllowThreads();
6356 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6357 wxPyEndAllowThreads(__tstate);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 {
6361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6362 }
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6370 PyObject *resultobj = 0;
6371 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6372 bool result;
6373 void *argp1 = 0 ;
6374 int res1 = 0 ;
6375 PyObject *swig_obj[1] ;
6376
6377 if (!args) SWIG_fail;
6378 swig_obj[0] = args;
6379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6380 if (!SWIG_IsOK(res1)) {
6381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6382 }
6383 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6384 {
6385 PyThreadState* __tstate = wxPyBeginAllowThreads();
6386 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6387 wxPyEndAllowThreads(__tstate);
6388 if (PyErr_Occurred()) SWIG_fail;
6389 }
6390 {
6391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6392 }
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6400 PyObject *resultobj = 0;
6401 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6402 bool result;
6403 void *argp1 = 0 ;
6404 int res1 = 0 ;
6405 PyObject *swig_obj[1] ;
6406
6407 if (!args) SWIG_fail;
6408 swig_obj[0] = args;
6409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6410 if (!SWIG_IsOK(res1)) {
6411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6412 }
6413 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6414 {
6415 PyThreadState* __tstate = wxPyBeginAllowThreads();
6416 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 {
6421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6422 }
6423 return resultobj;
6424 fail:
6425 return NULL;
6426 }
6427
6428
6429 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6430 PyObject *resultobj = 0;
6431 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6432 bool result;
6433 void *argp1 = 0 ;
6434 int res1 = 0 ;
6435 PyObject *swig_obj[1] ;
6436
6437 if (!args) SWIG_fail;
6438 swig_obj[0] = args;
6439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6440 if (!SWIG_IsOK(res1)) {
6441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6442 }
6443 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 {
6451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6452 }
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6460 PyObject *resultobj = 0;
6461 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6462 bool result;
6463 void *argp1 = 0 ;
6464 int res1 = 0 ;
6465 PyObject *swig_obj[1] ;
6466
6467 if (!args) SWIG_fail;
6468 swig_obj[0] = args;
6469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6470 if (!SWIG_IsOK(res1)) {
6471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6472 }
6473 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6474 {
6475 PyThreadState* __tstate = wxPyBeginAllowThreads();
6476 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6477 wxPyEndAllowThreads(__tstate);
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 {
6481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6482 }
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6490 PyObject *resultobj = 0;
6491 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6492 bool result;
6493 void *argp1 = 0 ;
6494 int res1 = 0 ;
6495 PyObject *swig_obj[1] ;
6496
6497 if (!args) SWIG_fail;
6498 swig_obj[0] = args;
6499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6500 if (!SWIG_IsOK(res1)) {
6501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6502 }
6503 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6504 {
6505 PyThreadState* __tstate = wxPyBeginAllowThreads();
6506 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6507 wxPyEndAllowThreads(__tstate);
6508 if (PyErr_Occurred()) SWIG_fail;
6509 }
6510 {
6511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6512 }
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6520 PyObject *resultobj = 0;
6521 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6522 bool result;
6523 void *argp1 = 0 ;
6524 int res1 = 0 ;
6525 PyObject *swig_obj[1] ;
6526
6527 if (!args) SWIG_fail;
6528 swig_obj[0] = args;
6529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6530 if (!SWIG_IsOK(res1)) {
6531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6532 }
6533 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6537 wxPyEndAllowThreads(__tstate);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 {
6541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6542 }
6543 return resultobj;
6544 fail:
6545 return NULL;
6546 }
6547
6548
6549 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6550 PyObject *resultobj = 0;
6551 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6552 bool result;
6553 void *argp1 = 0 ;
6554 int res1 = 0 ;
6555 PyObject *swig_obj[1] ;
6556
6557 if (!args) SWIG_fail;
6558 swig_obj[0] = args;
6559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6560 if (!SWIG_IsOK(res1)) {
6561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6562 }
6563 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6564 {
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 {
6571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6572 }
6573 return resultobj;
6574 fail:
6575 return NULL;
6576 }
6577
6578
6579 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6580 PyObject *resultobj = 0;
6581 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6582 wxColour result;
6583 void *argp1 = 0 ;
6584 int res1 = 0 ;
6585 PyObject *swig_obj[1] ;
6586
6587 if (!args) SWIG_fail;
6588 swig_obj[0] = args;
6589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6590 if (!SWIG_IsOK(res1)) {
6591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6592 }
6593 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6594 {
6595 PyThreadState* __tstate = wxPyBeginAllowThreads();
6596 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6608 PyObject *resultobj = 0;
6609 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6610 wxColour result;
6611 void *argp1 = 0 ;
6612 int res1 = 0 ;
6613 PyObject *swig_obj[1] ;
6614
6615 if (!args) SWIG_fail;
6616 swig_obj[0] = args;
6617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6618 if (!SWIG_IsOK(res1)) {
6619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6620 }
6621 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636 PyObject *resultobj = 0;
6637 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6638 wxFont result;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 PyObject *swig_obj[1] ;
6642
6643 if (!args) SWIG_fail;
6644 swig_obj[0] = args;
6645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6646 if (!SWIG_IsOK(res1)) {
6647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6648 }
6649 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6650 {
6651 PyThreadState* __tstate = wxPyBeginAllowThreads();
6652 result = ((wxGridCellAttr const *)arg1)->GetFont();
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6664 PyObject *resultobj = 0;
6665 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6666 int *arg2 = (int *) 0 ;
6667 int *arg3 = (int *) 0 ;
6668 void *argp1 = 0 ;
6669 int res1 = 0 ;
6670 int temp2 ;
6671 int res2 = SWIG_TMPOBJ ;
6672 int temp3 ;
6673 int res3 = SWIG_TMPOBJ ;
6674 PyObject *swig_obj[1] ;
6675
6676 arg2 = &temp2;
6677 arg3 = &temp3;
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 resultobj = SWIG_Py_Void();
6692 if (SWIG_IsTmpObj(res2)) {
6693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6694 } else {
6695 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6697 }
6698 if (SWIG_IsTmpObj(res3)) {
6699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6700 } else {
6701 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6703 }
6704 return resultobj;
6705 fail:
6706 return NULL;
6707 }
6708
6709
6710 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6711 PyObject *resultobj = 0;
6712 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6713 int *arg2 = (int *) 0 ;
6714 int *arg3 = (int *) 0 ;
6715 void *argp1 = 0 ;
6716 int res1 = 0 ;
6717 int temp2 ;
6718 int res2 = SWIG_TMPOBJ ;
6719 int temp3 ;
6720 int res3 = SWIG_TMPOBJ ;
6721 PyObject *swig_obj[1] ;
6722
6723 arg2 = &temp2;
6724 arg3 = &temp3;
6725 if (!args) SWIG_fail;
6726 swig_obj[0] = args;
6727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6728 if (!SWIG_IsOK(res1)) {
6729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6730 }
6731 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6735 wxPyEndAllowThreads(__tstate);
6736 if (PyErr_Occurred()) SWIG_fail;
6737 }
6738 resultobj = SWIG_Py_Void();
6739 if (SWIG_IsTmpObj(res2)) {
6740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6741 } else {
6742 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6744 }
6745 if (SWIG_IsTmpObj(res3)) {
6746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6747 } else {
6748 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6750 }
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6758 PyObject *resultobj = 0;
6759 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6760 bool result;
6761 void *argp1 = 0 ;
6762 int res1 = 0 ;
6763 PyObject *swig_obj[1] ;
6764
6765 if (!args) SWIG_fail;
6766 swig_obj[0] = args;
6767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6768 if (!SWIG_IsOK(res1)) {
6769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6770 }
6771 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 {
6779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6780 }
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6788 PyObject *resultobj = 0;
6789 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6790 wxGrid *arg2 = (wxGrid *) 0 ;
6791 int arg3 ;
6792 int arg4 ;
6793 wxGridCellRenderer *result = 0 ;
6794 void *argp1 = 0 ;
6795 int res1 = 0 ;
6796 void *argp2 = 0 ;
6797 int res2 = 0 ;
6798 int val3 ;
6799 int ecode3 = 0 ;
6800 int val4 ;
6801 int ecode4 = 0 ;
6802 PyObject * obj0 = 0 ;
6803 PyObject * obj1 = 0 ;
6804 PyObject * obj2 = 0 ;
6805 PyObject * obj3 = 0 ;
6806 char * kwnames[] = {
6807 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6808 };
6809
6810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6812 if (!SWIG_IsOK(res1)) {
6813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6814 }
6815 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6817 if (!SWIG_IsOK(res2)) {
6818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6819 }
6820 arg2 = reinterpret_cast< wxGrid * >(argp2);
6821 ecode3 = SWIG_AsVal_int(obj2, &val3);
6822 if (!SWIG_IsOK(ecode3)) {
6823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6824 }
6825 arg3 = static_cast< int >(val3);
6826 ecode4 = SWIG_AsVal_int(obj3, &val4);
6827 if (!SWIG_IsOK(ecode4)) {
6828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6829 }
6830 arg4 = static_cast< int >(val4);
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 {
6838 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6839 }
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6847 PyObject *resultobj = 0;
6848 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6849 wxGrid *arg2 = (wxGrid *) 0 ;
6850 int arg3 ;
6851 int arg4 ;
6852 wxGridCellEditor *result = 0 ;
6853 void *argp1 = 0 ;
6854 int res1 = 0 ;
6855 void *argp2 = 0 ;
6856 int res2 = 0 ;
6857 int val3 ;
6858 int ecode3 = 0 ;
6859 int val4 ;
6860 int ecode4 = 0 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 PyObject * obj2 = 0 ;
6864 PyObject * obj3 = 0 ;
6865 char * kwnames[] = {
6866 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6867 };
6868
6869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6871 if (!SWIG_IsOK(res1)) {
6872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6873 }
6874 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6876 if (!SWIG_IsOK(res2)) {
6877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6878 }
6879 arg2 = reinterpret_cast< wxGrid * >(argp2);
6880 ecode3 = SWIG_AsVal_int(obj2, &val3);
6881 if (!SWIG_IsOK(ecode3)) {
6882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6883 }
6884 arg3 = static_cast< int >(val3);
6885 ecode4 = SWIG_AsVal_int(obj3, &val4);
6886 if (!SWIG_IsOK(ecode4)) {
6887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6888 }
6889 arg4 = static_cast< int >(val4);
6890 {
6891 PyThreadState* __tstate = wxPyBeginAllowThreads();
6892 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 {
6897 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6898 }
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6906 PyObject *resultobj = 0;
6907 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6908 bool result;
6909 void *argp1 = 0 ;
6910 int res1 = 0 ;
6911 PyObject *swig_obj[1] ;
6912
6913 if (!args) SWIG_fail;
6914 swig_obj[0] = args;
6915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6916 if (!SWIG_IsOK(res1)) {
6917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6918 }
6919 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6920 {
6921 PyThreadState* __tstate = wxPyBeginAllowThreads();
6922 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 {
6927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6928 }
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6936 PyObject *resultobj = 0;
6937 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6938 wxGridCellAttr::wxAttrKind result;
6939 void *argp1 = 0 ;
6940 int res1 = 0 ;
6941 PyObject *swig_obj[1] ;
6942
6943 if (!args) SWIG_fail;
6944 swig_obj[0] = args;
6945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6946 if (!SWIG_IsOK(res1)) {
6947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6948 }
6949 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6950 {
6951 PyThreadState* __tstate = wxPyBeginAllowThreads();
6952 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_From_int(static_cast< int >(result));
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj = 0;
6965 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6966 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6967 void *argp1 = 0 ;
6968 int res1 = 0 ;
6969 void *argp2 = 0 ;
6970 int res2 = 0 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char * kwnames[] = {
6974 (char *) "self",(char *) "defAttr", NULL
6975 };
6976
6977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6979 if (!SWIG_IsOK(res1)) {
6980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6981 }
6982 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6984 if (!SWIG_IsOK(res2)) {
6985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6986 }
6987 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6988 {
6989 PyThreadState* __tstate = wxPyBeginAllowThreads();
6990 (arg1)->SetDefAttr(arg2);
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_Py_Void();
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7002 PyObject *obj;
7003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7004 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7005 return SWIG_Py_Void();
7006 }
7007
7008 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 return SWIG_Python_InitShadowInstance(args);
7010 }
7011
7012 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7013 PyObject *resultobj = 0;
7014 wxGridCellAttrProvider *result = 0 ;
7015
7016 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7017 {
7018 PyThreadState* __tstate = wxPyBeginAllowThreads();
7019 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7020 wxPyEndAllowThreads(__tstate);
7021 if (PyErr_Occurred()) SWIG_fail;
7022 }
7023 {
7024 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7025 }
7026 return resultobj;
7027 fail:
7028 return NULL;
7029 }
7030
7031
7032 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7033 PyObject *resultobj = 0;
7034 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7035 PyObject *arg2 = (PyObject *) 0 ;
7036 void *argp1 = 0 ;
7037 int res1 = 0 ;
7038 PyObject * obj0 = 0 ;
7039 PyObject * obj1 = 0 ;
7040 char * kwnames[] = {
7041 (char *) "self",(char *) "_self", NULL
7042 };
7043
7044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7046 if (!SWIG_IsOK(res1)) {
7047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7048 }
7049 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7050 arg2 = obj1;
7051 {
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_Py_Void();
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7067 int arg2 ;
7068 int arg3 ;
7069 wxGridCellAttr::wxAttrKind arg4 ;
7070 wxGridCellAttr *result = 0 ;
7071 void *argp1 = 0 ;
7072 int res1 = 0 ;
7073 int val2 ;
7074 int ecode2 = 0 ;
7075 int val3 ;
7076 int ecode3 = 0 ;
7077 int val4 ;
7078 int ecode4 = 0 ;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 PyObject * obj2 = 0 ;
7082 PyObject * obj3 = 0 ;
7083 char * kwnames[] = {
7084 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7085 };
7086
7087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7089 if (!SWIG_IsOK(res1)) {
7090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7091 }
7092 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7093 ecode2 = SWIG_AsVal_int(obj1, &val2);
7094 if (!SWIG_IsOK(ecode2)) {
7095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7096 }
7097 arg2 = static_cast< int >(val2);
7098 ecode3 = SWIG_AsVal_int(obj2, &val3);
7099 if (!SWIG_IsOK(ecode3)) {
7100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7101 }
7102 arg3 = static_cast< int >(val3);
7103 ecode4 = SWIG_AsVal_int(obj3, &val4);
7104 if (!SWIG_IsOK(ecode4)) {
7105 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7106 }
7107 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7111 wxPyEndAllowThreads(__tstate);
7112 if (PyErr_Occurred()) SWIG_fail;
7113 }
7114 {
7115 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7116 }
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj = 0;
7125 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7126 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7127 int arg3 ;
7128 int arg4 ;
7129 void *argp1 = 0 ;
7130 int res1 = 0 ;
7131 void *argp2 = 0 ;
7132 int res2 = 0 ;
7133 int val3 ;
7134 int ecode3 = 0 ;
7135 int val4 ;
7136 int ecode4 = 0 ;
7137 PyObject * obj0 = 0 ;
7138 PyObject * obj1 = 0 ;
7139 PyObject * obj2 = 0 ;
7140 PyObject * obj3 = 0 ;
7141 char * kwnames[] = {
7142 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7143 };
7144
7145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7147 if (!SWIG_IsOK(res1)) {
7148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7149 }
7150 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7151 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7152 if (!SWIG_IsOK(res2)) {
7153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7154 }
7155 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7156 ecode3 = SWIG_AsVal_int(obj2, &val3);
7157 if (!SWIG_IsOK(ecode3)) {
7158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7159 }
7160 arg3 = static_cast< int >(val3);
7161 ecode4 = SWIG_AsVal_int(obj3, &val4);
7162 if (!SWIG_IsOK(ecode4)) {
7163 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7164 }
7165 arg4 = static_cast< int >(val4);
7166 {
7167 PyThreadState* __tstate = wxPyBeginAllowThreads();
7168 (arg1)->SetAttr(arg2,arg3,arg4);
7169 wxPyEndAllowThreads(__tstate);
7170 if (PyErr_Occurred()) SWIG_fail;
7171 }
7172 resultobj = SWIG_Py_Void();
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj = 0;
7181 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7182 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7183 int arg3 ;
7184 void *argp1 = 0 ;
7185 int res1 = 0 ;
7186 void *argp2 = 0 ;
7187 int res2 = 0 ;
7188 int val3 ;
7189 int ecode3 = 0 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 PyObject * obj2 = 0 ;
7193 char * kwnames[] = {
7194 (char *) "self",(char *) "attr",(char *) "row", NULL
7195 };
7196
7197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7199 if (!SWIG_IsOK(res1)) {
7200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7201 }
7202 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7204 if (!SWIG_IsOK(res2)) {
7205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7206 }
7207 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7208 ecode3 = SWIG_AsVal_int(obj2, &val3);
7209 if (!SWIG_IsOK(ecode3)) {
7210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7211 }
7212 arg3 = static_cast< int >(val3);
7213 {
7214 PyThreadState* __tstate = wxPyBeginAllowThreads();
7215 (arg1)->SetRowAttr(arg2,arg3);
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 resultobj = SWIG_Py_Void();
7220 return resultobj;
7221 fail:
7222 return NULL;
7223 }
7224
7225
7226 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7227 PyObject *resultobj = 0;
7228 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7229 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7230 int arg3 ;
7231 void *argp1 = 0 ;
7232 int res1 = 0 ;
7233 void *argp2 = 0 ;
7234 int res2 = 0 ;
7235 int val3 ;
7236 int ecode3 = 0 ;
7237 PyObject * obj0 = 0 ;
7238 PyObject * obj1 = 0 ;
7239 PyObject * obj2 = 0 ;
7240 char * kwnames[] = {
7241 (char *) "self",(char *) "attr",(char *) "col", NULL
7242 };
7243
7244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7246 if (!SWIG_IsOK(res1)) {
7247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7248 }
7249 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7250 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7251 if (!SWIG_IsOK(res2)) {
7252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7253 }
7254 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7255 ecode3 = SWIG_AsVal_int(obj2, &val3);
7256 if (!SWIG_IsOK(ecode3)) {
7257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7258 }
7259 arg3 = static_cast< int >(val3);
7260 {
7261 PyThreadState* __tstate = wxPyBeginAllowThreads();
7262 (arg1)->SetColAttr(arg2,arg3);
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = SWIG_Py_Void();
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj = 0;
7275 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7276 size_t arg2 ;
7277 int arg3 ;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 size_t val2 ;
7281 int ecode2 = 0 ;
7282 int val3 ;
7283 int ecode3 = 0 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 PyObject * obj2 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7295 }
7296 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7297 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7298 if (!SWIG_IsOK(ecode2)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7300 }
7301 arg2 = static_cast< size_t >(val2);
7302 ecode3 = SWIG_AsVal_int(obj2, &val3);
7303 if (!SWIG_IsOK(ecode3)) {
7304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7305 }
7306 arg3 = static_cast< int >(val3);
7307 {
7308 PyThreadState* __tstate = wxPyBeginAllowThreads();
7309 (arg1)->UpdateAttrRows(arg2,arg3);
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_Py_Void();
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = 0;
7322 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7323 size_t arg2 ;
7324 int arg3 ;
7325 void *argp1 = 0 ;
7326 int res1 = 0 ;
7327 size_t val2 ;
7328 int ecode2 = 0 ;
7329 int val3 ;
7330 int ecode3 = 0 ;
7331 PyObject * obj0 = 0 ;
7332 PyObject * obj1 = 0 ;
7333 PyObject * obj2 = 0 ;
7334 char * kwnames[] = {
7335 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7336 };
7337
7338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7340 if (!SWIG_IsOK(res1)) {
7341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7342 }
7343 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7344 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7345 if (!SWIG_IsOK(ecode2)) {
7346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7347 }
7348 arg2 = static_cast< size_t >(val2);
7349 ecode3 = SWIG_AsVal_int(obj2, &val3);
7350 if (!SWIG_IsOK(ecode3)) {
7351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7352 }
7353 arg3 = static_cast< int >(val3);
7354 {
7355 PyThreadState* __tstate = wxPyBeginAllowThreads();
7356 (arg1)->UpdateAttrCols(arg2,arg3);
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_Py_Void();
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7368 PyObject *obj;
7369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7370 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7371 return SWIG_Py_Void();
7372 }
7373
7374 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7375 return SWIG_Python_InitShadowInstance(args);
7376 }
7377
7378 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7379 PyObject *resultobj = 0;
7380 wxPyGridCellAttrProvider *result = 0 ;
7381
7382 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7383 {
7384 PyThreadState* __tstate = wxPyBeginAllowThreads();
7385 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7386 wxPyEndAllowThreads(__tstate);
7387 if (PyErr_Occurred()) SWIG_fail;
7388 }
7389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7390 return resultobj;
7391 fail:
7392 return NULL;
7393 }
7394
7395
7396 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7397 PyObject *resultobj = 0;
7398 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7399 PyObject *arg2 = (PyObject *) 0 ;
7400 PyObject *arg3 = (PyObject *) 0 ;
7401 void *argp1 = 0 ;
7402 int res1 = 0 ;
7403 PyObject * obj0 = 0 ;
7404 PyObject * obj1 = 0 ;
7405 PyObject * obj2 = 0 ;
7406 char * kwnames[] = {
7407 (char *) "self",(char *) "self",(char *) "_class", NULL
7408 };
7409
7410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7412 if (!SWIG_IsOK(res1)) {
7413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7414 }
7415 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7416 arg2 = obj1;
7417 arg3 = obj2;
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 (arg1)->_setCallbackInfo(arg2,arg3);
7421 wxPyEndAllowThreads(__tstate);
7422 if (PyErr_Occurred()) SWIG_fail;
7423 }
7424 resultobj = SWIG_Py_Void();
7425 return resultobj;
7426 fail:
7427 return NULL;
7428 }
7429
7430
7431 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7432 PyObject *resultobj = 0;
7433 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7434 int arg2 ;
7435 int arg3 ;
7436 wxGridCellAttr::wxAttrKind arg4 ;
7437 wxGridCellAttr *result = 0 ;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 int val2 ;
7441 int ecode2 = 0 ;
7442 int val3 ;
7443 int ecode3 = 0 ;
7444 int val4 ;
7445 int ecode4 = 0 ;
7446 PyObject * obj0 = 0 ;
7447 PyObject * obj1 = 0 ;
7448 PyObject * obj2 = 0 ;
7449 PyObject * obj3 = 0 ;
7450 char * kwnames[] = {
7451 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7452 };
7453
7454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7456 if (!SWIG_IsOK(res1)) {
7457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7458 }
7459 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7460 ecode2 = SWIG_AsVal_int(obj1, &val2);
7461 if (!SWIG_IsOK(ecode2)) {
7462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7463 }
7464 arg2 = static_cast< int >(val2);
7465 ecode3 = SWIG_AsVal_int(obj2, &val3);
7466 if (!SWIG_IsOK(ecode3)) {
7467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7468 }
7469 arg3 = static_cast< int >(val3);
7470 ecode4 = SWIG_AsVal_int(obj3, &val4);
7471 if (!SWIG_IsOK(ecode4)) {
7472 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7473 }
7474 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 {
7482 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7483 }
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7491 PyObject *resultobj = 0;
7492 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7493 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7494 int arg3 ;
7495 int arg4 ;
7496 void *argp1 = 0 ;
7497 int res1 = 0 ;
7498 void *argp2 = 0 ;
7499 int res2 = 0 ;
7500 int val3 ;
7501 int ecode3 = 0 ;
7502 int val4 ;
7503 int ecode4 = 0 ;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 PyObject * obj2 = 0 ;
7507 PyObject * obj3 = 0 ;
7508 char * kwnames[] = {
7509 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7510 };
7511
7512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7516 }
7517 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7519 if (!SWIG_IsOK(res2)) {
7520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7521 }
7522 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7523 ecode3 = SWIG_AsVal_int(obj2, &val3);
7524 if (!SWIG_IsOK(ecode3)) {
7525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7526 }
7527 arg3 = static_cast< int >(val3);
7528 ecode4 = SWIG_AsVal_int(obj3, &val4);
7529 if (!SWIG_IsOK(ecode4)) {
7530 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7531 }
7532 arg4 = static_cast< int >(val4);
7533 {
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 (arg1)->SetAttr(arg2,arg3,arg4);
7536 wxPyEndAllowThreads(__tstate);
7537 if (PyErr_Occurred()) SWIG_fail;
7538 }
7539 resultobj = SWIG_Py_Void();
7540 return resultobj;
7541 fail:
7542 return NULL;
7543 }
7544
7545
7546 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7547 PyObject *resultobj = 0;
7548 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7549 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7550 int arg3 ;
7551 void *argp1 = 0 ;
7552 int res1 = 0 ;
7553 void *argp2 = 0 ;
7554 int res2 = 0 ;
7555 int val3 ;
7556 int ecode3 = 0 ;
7557 PyObject * obj0 = 0 ;
7558 PyObject * obj1 = 0 ;
7559 PyObject * obj2 = 0 ;
7560 char * kwnames[] = {
7561 (char *) "self",(char *) "attr",(char *) "row", NULL
7562 };
7563
7564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7566 if (!SWIG_IsOK(res1)) {
7567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7568 }
7569 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7571 if (!SWIG_IsOK(res2)) {
7572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7573 }
7574 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7575 ecode3 = SWIG_AsVal_int(obj2, &val3);
7576 if (!SWIG_IsOK(ecode3)) {
7577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7578 }
7579 arg3 = static_cast< int >(val3);
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 (arg1)->SetRowAttr(arg2,arg3);
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 resultobj = SWIG_Py_Void();
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7594 PyObject *resultobj = 0;
7595 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7596 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7597 int arg3 ;
7598 void *argp1 = 0 ;
7599 int res1 = 0 ;
7600 void *argp2 = 0 ;
7601 int res2 = 0 ;
7602 int val3 ;
7603 int ecode3 = 0 ;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 PyObject * obj2 = 0 ;
7607 char * kwnames[] = {
7608 (char *) "self",(char *) "attr",(char *) "col", NULL
7609 };
7610
7611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7613 if (!SWIG_IsOK(res1)) {
7614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7615 }
7616 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7618 if (!SWIG_IsOK(res2)) {
7619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7620 }
7621 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7622 ecode3 = SWIG_AsVal_int(obj2, &val3);
7623 if (!SWIG_IsOK(ecode3)) {
7624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7625 }
7626 arg3 = static_cast< int >(val3);
7627 {
7628 PyThreadState* __tstate = wxPyBeginAllowThreads();
7629 (arg1)->SetColAttr(arg2,arg3);
7630 wxPyEndAllowThreads(__tstate);
7631 if (PyErr_Occurred()) SWIG_fail;
7632 }
7633 resultobj = SWIG_Py_Void();
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7641 PyObject *obj;
7642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7643 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7644 return SWIG_Py_Void();
7645 }
7646
7647 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7648 return SWIG_Python_InitShadowInstance(args);
7649 }
7650
7651 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7652 PyObject *resultobj = 0;
7653 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7654 void *argp1 = 0 ;
7655 int res1 = 0 ;
7656 PyObject *swig_obj[1] ;
7657
7658 if (!args) SWIG_fail;
7659 swig_obj[0] = args;
7660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7661 if (!SWIG_IsOK(res1)) {
7662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7663 }
7664 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7665 {
7666 PyThreadState* __tstate = wxPyBeginAllowThreads();
7667 delete arg1;
7668
7669 wxPyEndAllowThreads(__tstate);
7670 if (PyErr_Occurred()) SWIG_fail;
7671 }
7672 resultobj = SWIG_Py_Void();
7673 return resultobj;
7674 fail:
7675 return NULL;
7676 }
7677
7678
7679 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7680 PyObject *resultobj = 0;
7681 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7682 PyObject *arg2 = (PyObject *) 0 ;
7683 void *argp1 = 0 ;
7684 int res1 = 0 ;
7685 PyObject * obj0 = 0 ;
7686 PyObject * obj1 = 0 ;
7687 char * kwnames[] = {
7688 (char *) "self",(char *) "_self", NULL
7689 };
7690
7691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7693 if (!SWIG_IsOK(res1)) {
7694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7695 }
7696 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7697 arg2 = obj1;
7698 {
7699 PyThreadState* __tstate = wxPyBeginAllowThreads();
7700 wxGridTableBase__setOORInfo(arg1,arg2);
7701 wxPyEndAllowThreads(__tstate);
7702 if (PyErr_Occurred()) SWIG_fail;
7703 }
7704 resultobj = SWIG_Py_Void();
7705 return resultobj;
7706 fail:
7707 return NULL;
7708 }
7709
7710
7711 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7712 PyObject *resultobj = 0;
7713 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7714 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7715 void *argp1 = 0 ;
7716 int res1 = 0 ;
7717 void *argp2 = 0 ;
7718 int res2 = 0 ;
7719 PyObject * obj0 = 0 ;
7720 PyObject * obj1 = 0 ;
7721 char * kwnames[] = {
7722 (char *) "self",(char *) "attrProvider", NULL
7723 };
7724
7725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7727 if (!SWIG_IsOK(res1)) {
7728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7729 }
7730 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7732 if (!SWIG_IsOK(res2)) {
7733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7734 }
7735 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7736 {
7737 PyThreadState* __tstate = wxPyBeginAllowThreads();
7738 (arg1)->SetAttrProvider(arg2);
7739 wxPyEndAllowThreads(__tstate);
7740 if (PyErr_Occurred()) SWIG_fail;
7741 }
7742 resultobj = SWIG_Py_Void();
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7750 PyObject *resultobj = 0;
7751 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7752 wxGridCellAttrProvider *result = 0 ;
7753 void *argp1 = 0 ;
7754 int res1 = 0 ;
7755 PyObject *swig_obj[1] ;
7756
7757 if (!args) SWIG_fail;
7758 swig_obj[0] = args;
7759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7760 if (!SWIG_IsOK(res1)) {
7761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7762 }
7763 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7764 {
7765 PyThreadState* __tstate = wxPyBeginAllowThreads();
7766 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 {
7771 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7772 }
7773 return resultobj;
7774 fail:
7775 return NULL;
7776 }
7777
7778
7779 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj = 0;
7781 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7782 wxGrid *arg2 = (wxGrid *) 0 ;
7783 void *argp1 = 0 ;
7784 int res1 = 0 ;
7785 void *argp2 = 0 ;
7786 int res2 = 0 ;
7787 PyObject * obj0 = 0 ;
7788 PyObject * obj1 = 0 ;
7789 char * kwnames[] = {
7790 (char *) "self",(char *) "grid", NULL
7791 };
7792
7793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7795 if (!SWIG_IsOK(res1)) {
7796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7797 }
7798 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7800 if (!SWIG_IsOK(res2)) {
7801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7802 }
7803 arg2 = reinterpret_cast< wxGrid * >(argp2);
7804 {
7805 PyThreadState* __tstate = wxPyBeginAllowThreads();
7806 (arg1)->SetView(arg2);
7807 wxPyEndAllowThreads(__tstate);
7808 if (PyErr_Occurred()) SWIG_fail;
7809 }
7810 resultobj = SWIG_Py_Void();
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7818 PyObject *resultobj = 0;
7819 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7820 wxGrid *result = 0 ;
7821 void *argp1 = 0 ;
7822 int res1 = 0 ;
7823 PyObject *swig_obj[1] ;
7824
7825 if (!args) SWIG_fail;
7826 swig_obj[0] = args;
7827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7828 if (!SWIG_IsOK(res1)) {
7829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7830 }
7831 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7832 {
7833 PyThreadState* __tstate = wxPyBeginAllowThreads();
7834 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7835 wxPyEndAllowThreads(__tstate);
7836 if (PyErr_Occurred()) SWIG_fail;
7837 }
7838 {
7839 resultobj = wxPyMake_wxObject(result, (bool)0);
7840 }
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7848 PyObject *resultobj = 0;
7849 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7850 int result;
7851 void *argp1 = 0 ;
7852 int res1 = 0 ;
7853 PyObject *swig_obj[1] ;
7854
7855 if (!args) SWIG_fail;
7856 swig_obj[0] = args;
7857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7858 if (!SWIG_IsOK(res1)) {
7859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7860 }
7861 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7862 {
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (int)(arg1)->GetNumberRows();
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 resultobj = SWIG_From_int(static_cast< int >(result));
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7876 PyObject *resultobj = 0;
7877 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7878 int result;
7879 void *argp1 = 0 ;
7880 int res1 = 0 ;
7881 PyObject *swig_obj[1] ;
7882
7883 if (!args) SWIG_fail;
7884 swig_obj[0] = args;
7885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7886 if (!SWIG_IsOK(res1)) {
7887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7888 }
7889 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 result = (int)(arg1)->GetNumberCols();
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 resultobj = SWIG_From_int(static_cast< int >(result));
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7904 PyObject *resultobj = 0;
7905 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7906 int arg2 ;
7907 int arg3 ;
7908 bool result;
7909 void *argp1 = 0 ;
7910 int res1 = 0 ;
7911 int val2 ;
7912 int ecode2 = 0 ;
7913 int val3 ;
7914 int ecode3 = 0 ;
7915 PyObject * obj0 = 0 ;
7916 PyObject * obj1 = 0 ;
7917 PyObject * obj2 = 0 ;
7918 char * kwnames[] = {
7919 (char *) "self",(char *) "row",(char *) "col", NULL
7920 };
7921
7922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7924 if (!SWIG_IsOK(res1)) {
7925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7926 }
7927 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7928 ecode2 = SWIG_AsVal_int(obj1, &val2);
7929 if (!SWIG_IsOK(ecode2)) {
7930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7931 }
7932 arg2 = static_cast< int >(val2);
7933 ecode3 = SWIG_AsVal_int(obj2, &val3);
7934 if (!SWIG_IsOK(ecode3)) {
7935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7936 }
7937 arg3 = static_cast< int >(val3);
7938 {
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7941 wxPyEndAllowThreads(__tstate);
7942 if (PyErr_Occurred()) SWIG_fail;
7943 }
7944 {
7945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7946 }
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7954 PyObject *resultobj = 0;
7955 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7956 int arg2 ;
7957 int arg3 ;
7958 wxString result;
7959 void *argp1 = 0 ;
7960 int res1 = 0 ;
7961 int val2 ;
7962 int ecode2 = 0 ;
7963 int val3 ;
7964 int ecode3 = 0 ;
7965 PyObject * obj0 = 0 ;
7966 PyObject * obj1 = 0 ;
7967 PyObject * obj2 = 0 ;
7968 char * kwnames[] = {
7969 (char *) "self",(char *) "row",(char *) "col", NULL
7970 };
7971
7972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7974 if (!SWIG_IsOK(res1)) {
7975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7976 }
7977 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7978 ecode2 = SWIG_AsVal_int(obj1, &val2);
7979 if (!SWIG_IsOK(ecode2)) {
7980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7981 }
7982 arg2 = static_cast< int >(val2);
7983 ecode3 = SWIG_AsVal_int(obj2, &val3);
7984 if (!SWIG_IsOK(ecode3)) {
7985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7986 }
7987 arg3 = static_cast< int >(val3);
7988 {
7989 PyThreadState* __tstate = wxPyBeginAllowThreads();
7990 result = (arg1)->GetValue(arg2,arg3);
7991 wxPyEndAllowThreads(__tstate);
7992 if (PyErr_Occurred()) SWIG_fail;
7993 }
7994 {
7995 #if wxUSE_UNICODE
7996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7997 #else
7998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7999 #endif
8000 }
8001 return resultobj;
8002 fail:
8003 return NULL;
8004 }
8005
8006
8007 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8008 PyObject *resultobj = 0;
8009 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8010 int arg2 ;
8011 int arg3 ;
8012 wxString *arg4 = 0 ;
8013 void *argp1 = 0 ;
8014 int res1 = 0 ;
8015 int val2 ;
8016 int ecode2 = 0 ;
8017 int val3 ;
8018 int ecode3 = 0 ;
8019 bool temp4 = false ;
8020 PyObject * obj0 = 0 ;
8021 PyObject * obj1 = 0 ;
8022 PyObject * obj2 = 0 ;
8023 PyObject * obj3 = 0 ;
8024 char * kwnames[] = {
8025 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8026 };
8027
8028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8030 if (!SWIG_IsOK(res1)) {
8031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8032 }
8033 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8034 ecode2 = SWIG_AsVal_int(obj1, &val2);
8035 if (!SWIG_IsOK(ecode2)) {
8036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8037 }
8038 arg2 = static_cast< int >(val2);
8039 ecode3 = SWIG_AsVal_int(obj2, &val3);
8040 if (!SWIG_IsOK(ecode3)) {
8041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8042 }
8043 arg3 = static_cast< int >(val3);
8044 {
8045 arg4 = wxString_in_helper(obj3);
8046 if (arg4 == NULL) SWIG_fail;
8047 temp4 = true;
8048 }
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8052 wxPyEndAllowThreads(__tstate);
8053 if (PyErr_Occurred()) SWIG_fail;
8054 }
8055 resultobj = SWIG_Py_Void();
8056 {
8057 if (temp4)
8058 delete arg4;
8059 }
8060 return resultobj;
8061 fail:
8062 {
8063 if (temp4)
8064 delete arg4;
8065 }
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj = 0;
8072 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8073 int arg2 ;
8074 int arg3 ;
8075 wxString result;
8076 void *argp1 = 0 ;
8077 int res1 = 0 ;
8078 int val2 ;
8079 int ecode2 = 0 ;
8080 int val3 ;
8081 int ecode3 = 0 ;
8082 PyObject * obj0 = 0 ;
8083 PyObject * obj1 = 0 ;
8084 PyObject * obj2 = 0 ;
8085 char * kwnames[] = {
8086 (char *) "self",(char *) "row",(char *) "col", NULL
8087 };
8088
8089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8091 if (!SWIG_IsOK(res1)) {
8092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8093 }
8094 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8095 ecode2 = SWIG_AsVal_int(obj1, &val2);
8096 if (!SWIG_IsOK(ecode2)) {
8097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8098 }
8099 arg2 = static_cast< int >(val2);
8100 ecode3 = SWIG_AsVal_int(obj2, &val3);
8101 if (!SWIG_IsOK(ecode3)) {
8102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8103 }
8104 arg3 = static_cast< int >(val3);
8105 {
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 result = (arg1)->GetTypeName(arg2,arg3);
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 {
8112 #if wxUSE_UNICODE
8113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8114 #else
8115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8116 #endif
8117 }
8118 return resultobj;
8119 fail:
8120 return NULL;
8121 }
8122
8123
8124 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj = 0;
8126 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8127 int arg2 ;
8128 int arg3 ;
8129 wxString *arg4 = 0 ;
8130 bool result;
8131 void *argp1 = 0 ;
8132 int res1 = 0 ;
8133 int val2 ;
8134 int ecode2 = 0 ;
8135 int val3 ;
8136 int ecode3 = 0 ;
8137 bool temp4 = false ;
8138 PyObject * obj0 = 0 ;
8139 PyObject * obj1 = 0 ;
8140 PyObject * obj2 = 0 ;
8141 PyObject * obj3 = 0 ;
8142 char * kwnames[] = {
8143 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8144 };
8145
8146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8148 if (!SWIG_IsOK(res1)) {
8149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8150 }
8151 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8152 ecode2 = SWIG_AsVal_int(obj1, &val2);
8153 if (!SWIG_IsOK(ecode2)) {
8154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8155 }
8156 arg2 = static_cast< int >(val2);
8157 ecode3 = SWIG_AsVal_int(obj2, &val3);
8158 if (!SWIG_IsOK(ecode3)) {
8159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8160 }
8161 arg3 = static_cast< int >(val3);
8162 {
8163 arg4 = wxString_in_helper(obj3);
8164 if (arg4 == NULL) SWIG_fail;
8165 temp4 = true;
8166 }
8167 {
8168 PyThreadState* __tstate = wxPyBeginAllowThreads();
8169 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8170 wxPyEndAllowThreads(__tstate);
8171 if (PyErr_Occurred()) SWIG_fail;
8172 }
8173 {
8174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8175 }
8176 {
8177 if (temp4)
8178 delete arg4;
8179 }
8180 return resultobj;
8181 fail:
8182 {
8183 if (temp4)
8184 delete arg4;
8185 }
8186 return NULL;
8187 }
8188
8189
8190 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8191 PyObject *resultobj = 0;
8192 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8193 int arg2 ;
8194 int arg3 ;
8195 wxString *arg4 = 0 ;
8196 bool result;
8197 void *argp1 = 0 ;
8198 int res1 = 0 ;
8199 int val2 ;
8200 int ecode2 = 0 ;
8201 int val3 ;
8202 int ecode3 = 0 ;
8203 bool temp4 = false ;
8204 PyObject * obj0 = 0 ;
8205 PyObject * obj1 = 0 ;
8206 PyObject * obj2 = 0 ;
8207 PyObject * obj3 = 0 ;
8208 char * kwnames[] = {
8209 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8210 };
8211
8212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8214 if (!SWIG_IsOK(res1)) {
8215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8216 }
8217 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8218 ecode2 = SWIG_AsVal_int(obj1, &val2);
8219 if (!SWIG_IsOK(ecode2)) {
8220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8221 }
8222 arg2 = static_cast< int >(val2);
8223 ecode3 = SWIG_AsVal_int(obj2, &val3);
8224 if (!SWIG_IsOK(ecode3)) {
8225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8226 }
8227 arg3 = static_cast< int >(val3);
8228 {
8229 arg4 = wxString_in_helper(obj3);
8230 if (arg4 == NULL) SWIG_fail;
8231 temp4 = true;
8232 }
8233 {
8234 PyThreadState* __tstate = wxPyBeginAllowThreads();
8235 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 {
8240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8241 }
8242 {
8243 if (temp4)
8244 delete arg4;
8245 }
8246 return resultobj;
8247 fail:
8248 {
8249 if (temp4)
8250 delete arg4;
8251 }
8252 return NULL;
8253 }
8254
8255
8256 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8257 PyObject *resultobj = 0;
8258 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8259 int arg2 ;
8260 int arg3 ;
8261 long result;
8262 void *argp1 = 0 ;
8263 int res1 = 0 ;
8264 int val2 ;
8265 int ecode2 = 0 ;
8266 int val3 ;
8267 int ecode3 = 0 ;
8268 PyObject * obj0 = 0 ;
8269 PyObject * obj1 = 0 ;
8270 PyObject * obj2 = 0 ;
8271 char * kwnames[] = {
8272 (char *) "self",(char *) "row",(char *) "col", NULL
8273 };
8274
8275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8277 if (!SWIG_IsOK(res1)) {
8278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8279 }
8280 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8281 ecode2 = SWIG_AsVal_int(obj1, &val2);
8282 if (!SWIG_IsOK(ecode2)) {
8283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8284 }
8285 arg2 = static_cast< int >(val2);
8286 ecode3 = SWIG_AsVal_int(obj2, &val3);
8287 if (!SWIG_IsOK(ecode3)) {
8288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8289 }
8290 arg3 = static_cast< int >(val3);
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 resultobj = SWIG_From_long(static_cast< long >(result));
8298 return resultobj;
8299 fail:
8300 return NULL;
8301 }
8302
8303
8304 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8305 PyObject *resultobj = 0;
8306 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8307 int arg2 ;
8308 int arg3 ;
8309 double result;
8310 void *argp1 = 0 ;
8311 int res1 = 0 ;
8312 int val2 ;
8313 int ecode2 = 0 ;
8314 int val3 ;
8315 int ecode3 = 0 ;
8316 PyObject * obj0 = 0 ;
8317 PyObject * obj1 = 0 ;
8318 PyObject * obj2 = 0 ;
8319 char * kwnames[] = {
8320 (char *) "self",(char *) "row",(char *) "col", NULL
8321 };
8322
8323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8327 }
8328 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8329 ecode2 = SWIG_AsVal_int(obj1, &val2);
8330 if (!SWIG_IsOK(ecode2)) {
8331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8332 }
8333 arg2 = static_cast< int >(val2);
8334 ecode3 = SWIG_AsVal_int(obj2, &val3);
8335 if (!SWIG_IsOK(ecode3)) {
8336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8337 }
8338 arg3 = static_cast< int >(val3);
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8342 wxPyEndAllowThreads(__tstate);
8343 if (PyErr_Occurred()) SWIG_fail;
8344 }
8345 resultobj = SWIG_From_double(static_cast< double >(result));
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8355 int arg2 ;
8356 int arg3 ;
8357 bool result;
8358 void *argp1 = 0 ;
8359 int res1 = 0 ;
8360 int val2 ;
8361 int ecode2 = 0 ;
8362 int val3 ;
8363 int ecode3 = 0 ;
8364 PyObject * obj0 = 0 ;
8365 PyObject * obj1 = 0 ;
8366 PyObject * obj2 = 0 ;
8367 char * kwnames[] = {
8368 (char *) "self",(char *) "row",(char *) "col", NULL
8369 };
8370
8371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8373 if (!SWIG_IsOK(res1)) {
8374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8375 }
8376 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8377 ecode2 = SWIG_AsVal_int(obj1, &val2);
8378 if (!SWIG_IsOK(ecode2)) {
8379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8380 }
8381 arg2 = static_cast< int >(val2);
8382 ecode3 = SWIG_AsVal_int(obj2, &val3);
8383 if (!SWIG_IsOK(ecode3)) {
8384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8385 }
8386 arg3 = static_cast< int >(val3);
8387 {
8388 PyThreadState* __tstate = wxPyBeginAllowThreads();
8389 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8390 wxPyEndAllowThreads(__tstate);
8391 if (PyErr_Occurred()) SWIG_fail;
8392 }
8393 {
8394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8395 }
8396 return resultobj;
8397 fail:
8398 return NULL;
8399 }
8400
8401
8402 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8403 PyObject *resultobj = 0;
8404 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8405 int arg2 ;
8406 int arg3 ;
8407 long arg4 ;
8408 void *argp1 = 0 ;
8409 int res1 = 0 ;
8410 int val2 ;
8411 int ecode2 = 0 ;
8412 int val3 ;
8413 int ecode3 = 0 ;
8414 long val4 ;
8415 int ecode4 = 0 ;
8416 PyObject * obj0 = 0 ;
8417 PyObject * obj1 = 0 ;
8418 PyObject * obj2 = 0 ;
8419 PyObject * obj3 = 0 ;
8420 char * kwnames[] = {
8421 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8422 };
8423
8424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8426 if (!SWIG_IsOK(res1)) {
8427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8428 }
8429 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8430 ecode2 = SWIG_AsVal_int(obj1, &val2);
8431 if (!SWIG_IsOK(ecode2)) {
8432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8433 }
8434 arg2 = static_cast< int >(val2);
8435 ecode3 = SWIG_AsVal_int(obj2, &val3);
8436 if (!SWIG_IsOK(ecode3)) {
8437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8438 }
8439 arg3 = static_cast< int >(val3);
8440 ecode4 = SWIG_AsVal_long(obj3, &val4);
8441 if (!SWIG_IsOK(ecode4)) {
8442 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8443 }
8444 arg4 = static_cast< long >(val4);
8445 {
8446 PyThreadState* __tstate = wxPyBeginAllowThreads();
8447 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_Py_Void();
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj = 0;
8460 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8461 int arg2 ;
8462 int arg3 ;
8463 double arg4 ;
8464 void *argp1 = 0 ;
8465 int res1 = 0 ;
8466 int val2 ;
8467 int ecode2 = 0 ;
8468 int val3 ;
8469 int ecode3 = 0 ;
8470 double val4 ;
8471 int ecode4 = 0 ;
8472 PyObject * obj0 = 0 ;
8473 PyObject * obj1 = 0 ;
8474 PyObject * obj2 = 0 ;
8475 PyObject * obj3 = 0 ;
8476 char * kwnames[] = {
8477 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8478 };
8479
8480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8482 if (!SWIG_IsOK(res1)) {
8483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8484 }
8485 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8486 ecode2 = SWIG_AsVal_int(obj1, &val2);
8487 if (!SWIG_IsOK(ecode2)) {
8488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8489 }
8490 arg2 = static_cast< int >(val2);
8491 ecode3 = SWIG_AsVal_int(obj2, &val3);
8492 if (!SWIG_IsOK(ecode3)) {
8493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8494 }
8495 arg3 = static_cast< int >(val3);
8496 ecode4 = SWIG_AsVal_double(obj3, &val4);
8497 if (!SWIG_IsOK(ecode4)) {
8498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8499 }
8500 arg4 = static_cast< double >(val4);
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_Py_Void();
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8515 PyObject *resultobj = 0;
8516 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8517 int arg2 ;
8518 int arg3 ;
8519 bool arg4 ;
8520 void *argp1 = 0 ;
8521 int res1 = 0 ;
8522 int val2 ;
8523 int ecode2 = 0 ;
8524 int val3 ;
8525 int ecode3 = 0 ;
8526 bool val4 ;
8527 int ecode4 = 0 ;
8528 PyObject * obj0 = 0 ;
8529 PyObject * obj1 = 0 ;
8530 PyObject * obj2 = 0 ;
8531 PyObject * obj3 = 0 ;
8532 char * kwnames[] = {
8533 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8534 };
8535
8536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8538 if (!SWIG_IsOK(res1)) {
8539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8540 }
8541 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8542 ecode2 = SWIG_AsVal_int(obj1, &val2);
8543 if (!SWIG_IsOK(ecode2)) {
8544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8545 }
8546 arg2 = static_cast< int >(val2);
8547 ecode3 = SWIG_AsVal_int(obj2, &val3);
8548 if (!SWIG_IsOK(ecode3)) {
8549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8550 }
8551 arg3 = static_cast< int >(val3);
8552 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8553 if (!SWIG_IsOK(ecode4)) {
8554 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8555 }
8556 arg4 = static_cast< bool >(val4);
8557 {
8558 PyThreadState* __tstate = wxPyBeginAllowThreads();
8559 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8560 wxPyEndAllowThreads(__tstate);
8561 if (PyErr_Occurred()) SWIG_fail;
8562 }
8563 resultobj = SWIG_Py_Void();
8564 return resultobj;
8565 fail:
8566 return NULL;
8567 }
8568
8569
8570 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8571 PyObject *resultobj = 0;
8572 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8573 void *argp1 = 0 ;
8574 int res1 = 0 ;
8575 PyObject *swig_obj[1] ;
8576
8577 if (!args) SWIG_fail;
8578 swig_obj[0] = args;
8579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8580 if (!SWIG_IsOK(res1)) {
8581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8582 }
8583 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8584 {
8585 PyThreadState* __tstate = wxPyBeginAllowThreads();
8586 (arg1)->Clear();
8587 wxPyEndAllowThreads(__tstate);
8588 if (PyErr_Occurred()) SWIG_fail;
8589 }
8590 resultobj = SWIG_Py_Void();
8591 return resultobj;
8592 fail:
8593 return NULL;
8594 }
8595
8596
8597 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8598 PyObject *resultobj = 0;
8599 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8600 size_t arg2 = (size_t) 0 ;
8601 size_t arg3 = (size_t) 1 ;
8602 bool result;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 size_t val2 ;
8606 int ecode2 = 0 ;
8607 size_t val3 ;
8608 int ecode3 = 0 ;
8609 PyObject * obj0 = 0 ;
8610 PyObject * obj1 = 0 ;
8611 PyObject * obj2 = 0 ;
8612 char * kwnames[] = {
8613 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8614 };
8615
8616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8618 if (!SWIG_IsOK(res1)) {
8619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8620 }
8621 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8622 if (obj1) {
8623 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8624 if (!SWIG_IsOK(ecode2)) {
8625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8626 }
8627 arg2 = static_cast< size_t >(val2);
8628 }
8629 if (obj2) {
8630 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8631 if (!SWIG_IsOK(ecode3)) {
8632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8633 }
8634 arg3 = static_cast< size_t >(val3);
8635 }
8636 {
8637 PyThreadState* __tstate = wxPyBeginAllowThreads();
8638 result = (bool)(arg1)->InsertRows(arg2,arg3);
8639 wxPyEndAllowThreads(__tstate);
8640 if (PyErr_Occurred()) SWIG_fail;
8641 }
8642 {
8643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8644 }
8645 return resultobj;
8646 fail:
8647 return NULL;
8648 }
8649
8650
8651 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj = 0;
8653 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8654 size_t arg2 = (size_t) 1 ;
8655 bool result;
8656 void *argp1 = 0 ;
8657 int res1 = 0 ;
8658 size_t val2 ;
8659 int ecode2 = 0 ;
8660 PyObject * obj0 = 0 ;
8661 PyObject * obj1 = 0 ;
8662 char * kwnames[] = {
8663 (char *) "self",(char *) "numRows", NULL
8664 };
8665
8666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8668 if (!SWIG_IsOK(res1)) {
8669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8670 }
8671 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8672 if (obj1) {
8673 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8674 if (!SWIG_IsOK(ecode2)) {
8675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8676 }
8677 arg2 = static_cast< size_t >(val2);
8678 }
8679 {
8680 PyThreadState* __tstate = wxPyBeginAllowThreads();
8681 result = (bool)(arg1)->AppendRows(arg2);
8682 wxPyEndAllowThreads(__tstate);
8683 if (PyErr_Occurred()) SWIG_fail;
8684 }
8685 {
8686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8687 }
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj = 0;
8696 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8697 size_t arg2 = (size_t) 0 ;
8698 size_t arg3 = (size_t) 1 ;
8699 bool result;
8700 void *argp1 = 0 ;
8701 int res1 = 0 ;
8702 size_t val2 ;
8703 int ecode2 = 0 ;
8704 size_t val3 ;
8705 int ecode3 = 0 ;
8706 PyObject * obj0 = 0 ;
8707 PyObject * obj1 = 0 ;
8708 PyObject * obj2 = 0 ;
8709 char * kwnames[] = {
8710 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8711 };
8712
8713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8715 if (!SWIG_IsOK(res1)) {
8716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8717 }
8718 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8719 if (obj1) {
8720 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8721 if (!SWIG_IsOK(ecode2)) {
8722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8723 }
8724 arg2 = static_cast< size_t >(val2);
8725 }
8726 if (obj2) {
8727 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8728 if (!SWIG_IsOK(ecode3)) {
8729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8730 }
8731 arg3 = static_cast< size_t >(val3);
8732 }
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8736 wxPyEndAllowThreads(__tstate);
8737 if (PyErr_Occurred()) SWIG_fail;
8738 }
8739 {
8740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8741 }
8742 return resultobj;
8743 fail:
8744 return NULL;
8745 }
8746
8747
8748 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8749 PyObject *resultobj = 0;
8750 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8751 size_t arg2 = (size_t) 0 ;
8752 size_t arg3 = (size_t) 1 ;
8753 bool result;
8754 void *argp1 = 0 ;
8755 int res1 = 0 ;
8756 size_t val2 ;
8757 int ecode2 = 0 ;
8758 size_t val3 ;
8759 int ecode3 = 0 ;
8760 PyObject * obj0 = 0 ;
8761 PyObject * obj1 = 0 ;
8762 PyObject * obj2 = 0 ;
8763 char * kwnames[] = {
8764 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8765 };
8766
8767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8769 if (!SWIG_IsOK(res1)) {
8770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8771 }
8772 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8773 if (obj1) {
8774 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8775 if (!SWIG_IsOK(ecode2)) {
8776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8777 }
8778 arg2 = static_cast< size_t >(val2);
8779 }
8780 if (obj2) {
8781 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8782 if (!SWIG_IsOK(ecode3)) {
8783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8784 }
8785 arg3 = static_cast< size_t >(val3);
8786 }
8787 {
8788 PyThreadState* __tstate = wxPyBeginAllowThreads();
8789 result = (bool)(arg1)->InsertCols(arg2,arg3);
8790 wxPyEndAllowThreads(__tstate);
8791 if (PyErr_Occurred()) SWIG_fail;
8792 }
8793 {
8794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8795 }
8796 return resultobj;
8797 fail:
8798 return NULL;
8799 }
8800
8801
8802 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8803 PyObject *resultobj = 0;
8804 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8805 size_t arg2 = (size_t) 1 ;
8806 bool result;
8807 void *argp1 = 0 ;
8808 int res1 = 0 ;
8809 size_t val2 ;
8810 int ecode2 = 0 ;
8811 PyObject * obj0 = 0 ;
8812 PyObject * obj1 = 0 ;
8813 char * kwnames[] = {
8814 (char *) "self",(char *) "numCols", NULL
8815 };
8816
8817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8819 if (!SWIG_IsOK(res1)) {
8820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8821 }
8822 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8823 if (obj1) {
8824 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8825 if (!SWIG_IsOK(ecode2)) {
8826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8827 }
8828 arg2 = static_cast< size_t >(val2);
8829 }
8830 {
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 result = (bool)(arg1)->AppendCols(arg2);
8833 wxPyEndAllowThreads(__tstate);
8834 if (PyErr_Occurred()) SWIG_fail;
8835 }
8836 {
8837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8838 }
8839 return resultobj;
8840 fail:
8841 return NULL;
8842 }
8843
8844
8845 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8846 PyObject *resultobj = 0;
8847 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8848 size_t arg2 = (size_t) 0 ;
8849 size_t arg3 = (size_t) 1 ;
8850 bool result;
8851 void *argp1 = 0 ;
8852 int res1 = 0 ;
8853 size_t val2 ;
8854 int ecode2 = 0 ;
8855 size_t val3 ;
8856 int ecode3 = 0 ;
8857 PyObject * obj0 = 0 ;
8858 PyObject * obj1 = 0 ;
8859 PyObject * obj2 = 0 ;
8860 char * kwnames[] = {
8861 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8862 };
8863
8864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8866 if (!SWIG_IsOK(res1)) {
8867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8868 }
8869 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8870 if (obj1) {
8871 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8872 if (!SWIG_IsOK(ecode2)) {
8873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8874 }
8875 arg2 = static_cast< size_t >(val2);
8876 }
8877 if (obj2) {
8878 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8879 if (!SWIG_IsOK(ecode3)) {
8880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8881 }
8882 arg3 = static_cast< size_t >(val3);
8883 }
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 {
8891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8892 }
8893 return resultobj;
8894 fail:
8895 return NULL;
8896 }
8897
8898
8899 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8900 PyObject *resultobj = 0;
8901 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8902 int arg2 ;
8903 wxString result;
8904 void *argp1 = 0 ;
8905 int res1 = 0 ;
8906 int val2 ;
8907 int ecode2 = 0 ;
8908 PyObject * obj0 = 0 ;
8909 PyObject * obj1 = 0 ;
8910 char * kwnames[] = {
8911 (char *) "self",(char *) "row", NULL
8912 };
8913
8914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8916 if (!SWIG_IsOK(res1)) {
8917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8918 }
8919 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8920 ecode2 = SWIG_AsVal_int(obj1, &val2);
8921 if (!SWIG_IsOK(ecode2)) {
8922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8923 }
8924 arg2 = static_cast< int >(val2);
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 result = (arg1)->GetRowLabelValue(arg2);
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 {
8932 #if wxUSE_UNICODE
8933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8934 #else
8935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8936 #endif
8937 }
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8945 PyObject *resultobj = 0;
8946 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8947 int arg2 ;
8948 wxString result;
8949 void *argp1 = 0 ;
8950 int res1 = 0 ;
8951 int val2 ;
8952 int ecode2 = 0 ;
8953 PyObject * obj0 = 0 ;
8954 PyObject * obj1 = 0 ;
8955 char * kwnames[] = {
8956 (char *) "self",(char *) "col", NULL
8957 };
8958
8959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8961 if (!SWIG_IsOK(res1)) {
8962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8963 }
8964 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8965 ecode2 = SWIG_AsVal_int(obj1, &val2);
8966 if (!SWIG_IsOK(ecode2)) {
8967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8968 }
8969 arg2 = static_cast< int >(val2);
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 result = (arg1)->GetColLabelValue(arg2);
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 {
8977 #if wxUSE_UNICODE
8978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8979 #else
8980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8981 #endif
8982 }
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj = 0;
8991 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8992 int arg2 ;
8993 wxString *arg3 = 0 ;
8994 void *argp1 = 0 ;
8995 int res1 = 0 ;
8996 int val2 ;
8997 int ecode2 = 0 ;
8998 bool temp3 = false ;
8999 PyObject * obj0 = 0 ;
9000 PyObject * obj1 = 0 ;
9001 PyObject * obj2 = 0 ;
9002 char * kwnames[] = {
9003 (char *) "self",(char *) "row",(char *) "value", NULL
9004 };
9005
9006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9008 if (!SWIG_IsOK(res1)) {
9009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9010 }
9011 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9012 ecode2 = SWIG_AsVal_int(obj1, &val2);
9013 if (!SWIG_IsOK(ecode2)) {
9014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9015 }
9016 arg2 = static_cast< int >(val2);
9017 {
9018 arg3 = wxString_in_helper(obj2);
9019 if (arg3 == NULL) SWIG_fail;
9020 temp3 = true;
9021 }
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9025 wxPyEndAllowThreads(__tstate);
9026 if (PyErr_Occurred()) SWIG_fail;
9027 }
9028 resultobj = SWIG_Py_Void();
9029 {
9030 if (temp3)
9031 delete arg3;
9032 }
9033 return resultobj;
9034 fail:
9035 {
9036 if (temp3)
9037 delete arg3;
9038 }
9039 return NULL;
9040 }
9041
9042
9043 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj = 0;
9045 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9046 int arg2 ;
9047 wxString *arg3 = 0 ;
9048 void *argp1 = 0 ;
9049 int res1 = 0 ;
9050 int val2 ;
9051 int ecode2 = 0 ;
9052 bool temp3 = false ;
9053 PyObject * obj0 = 0 ;
9054 PyObject * obj1 = 0 ;
9055 PyObject * obj2 = 0 ;
9056 char * kwnames[] = {
9057 (char *) "self",(char *) "col",(char *) "value", NULL
9058 };
9059
9060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9062 if (!SWIG_IsOK(res1)) {
9063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9064 }
9065 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9066 ecode2 = SWIG_AsVal_int(obj1, &val2);
9067 if (!SWIG_IsOK(ecode2)) {
9068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9069 }
9070 arg2 = static_cast< int >(val2);
9071 {
9072 arg3 = wxString_in_helper(obj2);
9073 if (arg3 == NULL) SWIG_fail;
9074 temp3 = true;
9075 }
9076 {
9077 PyThreadState* __tstate = wxPyBeginAllowThreads();
9078 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 resultobj = SWIG_Py_Void();
9083 {
9084 if (temp3)
9085 delete arg3;
9086 }
9087 return resultobj;
9088 fail:
9089 {
9090 if (temp3)
9091 delete arg3;
9092 }
9093 return NULL;
9094 }
9095
9096
9097 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9098 PyObject *resultobj = 0;
9099 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9100 bool result;
9101 void *argp1 = 0 ;
9102 int res1 = 0 ;
9103 PyObject *swig_obj[1] ;
9104
9105 if (!args) SWIG_fail;
9106 swig_obj[0] = args;
9107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9108 if (!SWIG_IsOK(res1)) {
9109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9110 }
9111 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 result = (bool)(arg1)->CanHaveAttributes();
9115 wxPyEndAllowThreads(__tstate);
9116 if (PyErr_Occurred()) SWIG_fail;
9117 }
9118 {
9119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9120 }
9121 return resultobj;
9122 fail:
9123 return NULL;
9124 }
9125
9126
9127 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9128 PyObject *resultobj = 0;
9129 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9130 int arg2 ;
9131 int arg3 ;
9132 wxGridCellAttr::wxAttrKind arg4 ;
9133 wxGridCellAttr *result = 0 ;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 int val2 ;
9137 int ecode2 = 0 ;
9138 int val3 ;
9139 int ecode3 = 0 ;
9140 int val4 ;
9141 int ecode4 = 0 ;
9142 PyObject * obj0 = 0 ;
9143 PyObject * obj1 = 0 ;
9144 PyObject * obj2 = 0 ;
9145 PyObject * obj3 = 0 ;
9146 char * kwnames[] = {
9147 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9148 };
9149
9150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9152 if (!SWIG_IsOK(res1)) {
9153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9154 }
9155 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9156 ecode2 = SWIG_AsVal_int(obj1, &val2);
9157 if (!SWIG_IsOK(ecode2)) {
9158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9159 }
9160 arg2 = static_cast< int >(val2);
9161 ecode3 = SWIG_AsVal_int(obj2, &val3);
9162 if (!SWIG_IsOK(ecode3)) {
9163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9164 }
9165 arg3 = static_cast< int >(val3);
9166 ecode4 = SWIG_AsVal_int(obj3, &val4);
9167 if (!SWIG_IsOK(ecode4)) {
9168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9169 }
9170 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9174 wxPyEndAllowThreads(__tstate);
9175 if (PyErr_Occurred()) SWIG_fail;
9176 }
9177 {
9178 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9179 }
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9187 PyObject *resultobj = 0;
9188 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9189 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9190 int arg3 ;
9191 int arg4 ;
9192 void *argp1 = 0 ;
9193 int res1 = 0 ;
9194 void *argp2 = 0 ;
9195 int res2 = 0 ;
9196 int val3 ;
9197 int ecode3 = 0 ;
9198 int val4 ;
9199 int ecode4 = 0 ;
9200 PyObject * obj0 = 0 ;
9201 PyObject * obj1 = 0 ;
9202 PyObject * obj2 = 0 ;
9203 PyObject * obj3 = 0 ;
9204 char * kwnames[] = {
9205 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9206 };
9207
9208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9210 if (!SWIG_IsOK(res1)) {
9211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9212 }
9213 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9214 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9215 if (!SWIG_IsOK(res2)) {
9216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9217 }
9218 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9219 ecode3 = SWIG_AsVal_int(obj2, &val3);
9220 if (!SWIG_IsOK(ecode3)) {
9221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9222 }
9223 arg3 = static_cast< int >(val3);
9224 ecode4 = SWIG_AsVal_int(obj3, &val4);
9225 if (!SWIG_IsOK(ecode4)) {
9226 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9227 }
9228 arg4 = static_cast< int >(val4);
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 (arg1)->SetAttr(arg2,arg3,arg4);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = SWIG_Py_Void();
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj = 0;
9244 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9245 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9246 int arg3 ;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 void *argp2 = 0 ;
9250 int res2 = 0 ;
9251 int val3 ;
9252 int ecode3 = 0 ;
9253 PyObject * obj0 = 0 ;
9254 PyObject * obj1 = 0 ;
9255 PyObject * obj2 = 0 ;
9256 char * kwnames[] = {
9257 (char *) "self",(char *) "attr",(char *) "row", NULL
9258 };
9259
9260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9262 if (!SWIG_IsOK(res1)) {
9263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9264 }
9265 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9267 if (!SWIG_IsOK(res2)) {
9268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9269 }
9270 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9271 ecode3 = SWIG_AsVal_int(obj2, &val3);
9272 if (!SWIG_IsOK(ecode3)) {
9273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9274 }
9275 arg3 = static_cast< int >(val3);
9276 {
9277 PyThreadState* __tstate = wxPyBeginAllowThreads();
9278 (arg1)->SetRowAttr(arg2,arg3);
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_Py_Void();
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
9289 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj = 0;
9291 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9292 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9293 int arg3 ;
9294 void *argp1 = 0 ;
9295 int res1 = 0 ;
9296 void *argp2 = 0 ;
9297 int res2 = 0 ;
9298 int val3 ;
9299 int ecode3 = 0 ;
9300 PyObject * obj0 = 0 ;
9301 PyObject * obj1 = 0 ;
9302 PyObject * obj2 = 0 ;
9303 char * kwnames[] = {
9304 (char *) "self",(char *) "attr",(char *) "col", NULL
9305 };
9306
9307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9309 if (!SWIG_IsOK(res1)) {
9310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9311 }
9312 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9314 if (!SWIG_IsOK(res2)) {
9315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9316 }
9317 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9318 ecode3 = SWIG_AsVal_int(obj2, &val3);
9319 if (!SWIG_IsOK(ecode3)) {
9320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9321 }
9322 arg3 = static_cast< int >(val3);
9323 {
9324 PyThreadState* __tstate = wxPyBeginAllowThreads();
9325 (arg1)->SetColAttr(arg2,arg3);
9326 wxPyEndAllowThreads(__tstate);
9327 if (PyErr_Occurred()) SWIG_fail;
9328 }
9329 resultobj = SWIG_Py_Void();
9330 return resultobj;
9331 fail:
9332 return NULL;
9333 }
9334
9335
9336 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9337 PyObject *obj;
9338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9339 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9340 return SWIG_Py_Void();
9341 }
9342
9343 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9344 PyObject *resultobj = 0;
9345 wxPyGridTableBase *result = 0 ;
9346
9347 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9351 wxPyEndAllowThreads(__tstate);
9352 if (PyErr_Occurred()) SWIG_fail;
9353 }
9354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9355 return resultobj;
9356 fail:
9357 return NULL;
9358 }
9359
9360
9361 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9362 PyObject *resultobj = 0;
9363 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9364 PyObject *arg2 = (PyObject *) 0 ;
9365 PyObject *arg3 = (PyObject *) 0 ;
9366 void *argp1 = 0 ;
9367 int res1 = 0 ;
9368 PyObject * obj0 = 0 ;
9369 PyObject * obj1 = 0 ;
9370 PyObject * obj2 = 0 ;
9371 char * kwnames[] = {
9372 (char *) "self",(char *) "self",(char *) "_class", NULL
9373 };
9374
9375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9377 if (!SWIG_IsOK(res1)) {
9378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9379 }
9380 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9381 arg2 = obj1;
9382 arg3 = obj2;
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 (arg1)->_setCallbackInfo(arg2,arg3);
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 resultobj = SWIG_Py_Void();
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9397 PyObject *resultobj = 0;
9398 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9399 void *argp1 = 0 ;
9400 int res1 = 0 ;
9401 PyObject *swig_obj[1] ;
9402
9403 if (!args) SWIG_fail;
9404 swig_obj[0] = args;
9405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9406 if (!SWIG_IsOK(res1)) {
9407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9408 }
9409 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9410 {
9411 PyThreadState* __tstate = wxPyBeginAllowThreads();
9412 wxPyGridTableBase_Destroy(arg1);
9413 wxPyEndAllowThreads(__tstate);
9414 if (PyErr_Occurred()) SWIG_fail;
9415 }
9416 resultobj = SWIG_Py_Void();
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9424 PyObject *obj;
9425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9426 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9427 return SWIG_Py_Void();
9428 }
9429
9430 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9431 return SWIG_Python_InitShadowInstance(args);
9432 }
9433
9434 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj = 0;
9436 int arg1 = (int) 0 ;
9437 int arg2 = (int) 0 ;
9438 wxGridStringTable *result = 0 ;
9439 int val1 ;
9440 int ecode1 = 0 ;
9441 int val2 ;
9442 int ecode2 = 0 ;
9443 PyObject * obj0 = 0 ;
9444 PyObject * obj1 = 0 ;
9445 char * kwnames[] = {
9446 (char *) "numRows",(char *) "numCols", NULL
9447 };
9448
9449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9450 if (obj0) {
9451 ecode1 = SWIG_AsVal_int(obj0, &val1);
9452 if (!SWIG_IsOK(ecode1)) {
9453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9454 }
9455 arg1 = static_cast< int >(val1);
9456 }
9457 if (obj1) {
9458 ecode2 = SWIG_AsVal_int(obj1, &val2);
9459 if (!SWIG_IsOK(ecode2)) {
9460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9461 }
9462 arg2 = static_cast< int >(val2);
9463 }
9464 {
9465 PyThreadState* __tstate = wxPyBeginAllowThreads();
9466 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9467 wxPyEndAllowThreads(__tstate);
9468 if (PyErr_Occurred()) SWIG_fail;
9469 }
9470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9471 return resultobj;
9472 fail:
9473 return NULL;
9474 }
9475
9476
9477 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9478 PyObject *obj;
9479 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9480 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9481 return SWIG_Py_Void();
9482 }
9483
9484 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9485 return SWIG_Python_InitShadowInstance(args);
9486 }
9487
9488 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9491 int arg2 ;
9492 int arg3 = (int) -1 ;
9493 int arg4 = (int) -1 ;
9494 wxGridTableMessage *result = 0 ;
9495 void *argp1 = 0 ;
9496 int res1 = 0 ;
9497 int val2 ;
9498 int ecode2 = 0 ;
9499 int val3 ;
9500 int ecode3 = 0 ;
9501 int val4 ;
9502 int ecode4 = 0 ;
9503 PyObject * obj0 = 0 ;
9504 PyObject * obj1 = 0 ;
9505 PyObject * obj2 = 0 ;
9506 PyObject * obj3 = 0 ;
9507 char * kwnames[] = {
9508 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9509 };
9510
9511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9513 if (!SWIG_IsOK(res1)) {
9514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9515 }
9516 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9517 ecode2 = SWIG_AsVal_int(obj1, &val2);
9518 if (!SWIG_IsOK(ecode2)) {
9519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9520 }
9521 arg2 = static_cast< int >(val2);
9522 if (obj2) {
9523 ecode3 = SWIG_AsVal_int(obj2, &val3);
9524 if (!SWIG_IsOK(ecode3)) {
9525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9526 }
9527 arg3 = static_cast< int >(val3);
9528 }
9529 if (obj3) {
9530 ecode4 = SWIG_AsVal_int(obj3, &val4);
9531 if (!SWIG_IsOK(ecode4)) {
9532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9533 }
9534 arg4 = static_cast< int >(val4);
9535 }
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
9549 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9550 PyObject *resultobj = 0;
9551 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9552 void *argp1 = 0 ;
9553 int res1 = 0 ;
9554 PyObject *swig_obj[1] ;
9555
9556 if (!args) SWIG_fail;
9557 swig_obj[0] = args;
9558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9559 if (!SWIG_IsOK(res1)) {
9560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9561 }
9562 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9563 {
9564 PyThreadState* __tstate = wxPyBeginAllowThreads();
9565 delete arg1;
9566
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 resultobj = SWIG_Py_Void();
9571 return resultobj;
9572 fail:
9573 return NULL;
9574 }
9575
9576
9577 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9578 PyObject *resultobj = 0;
9579 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9580 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9581 void *argp1 = 0 ;
9582 int res1 = 0 ;
9583 void *argp2 = 0 ;
9584 int res2 = 0 ;
9585 PyObject * obj0 = 0 ;
9586 PyObject * obj1 = 0 ;
9587 char * kwnames[] = {
9588 (char *) "self",(char *) "table", NULL
9589 };
9590
9591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9593 if (!SWIG_IsOK(res1)) {
9594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9595 }
9596 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9598 if (!SWIG_IsOK(res2)) {
9599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9600 }
9601 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9602 {
9603 PyThreadState* __tstate = wxPyBeginAllowThreads();
9604 (arg1)->SetTableObject(arg2);
9605 wxPyEndAllowThreads(__tstate);
9606 if (PyErr_Occurred()) SWIG_fail;
9607 }
9608 resultobj = SWIG_Py_Void();
9609 return resultobj;
9610 fail:
9611 return NULL;
9612 }
9613
9614
9615 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9616 PyObject *resultobj = 0;
9617 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9618 wxGridTableBase *result = 0 ;
9619 void *argp1 = 0 ;
9620 int res1 = 0 ;
9621 PyObject *swig_obj[1] ;
9622
9623 if (!args) SWIG_fail;
9624 swig_obj[0] = args;
9625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9626 if (!SWIG_IsOK(res1)) {
9627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9628 }
9629 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9630 {
9631 PyThreadState* __tstate = wxPyBeginAllowThreads();
9632 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9633 wxPyEndAllowThreads(__tstate);
9634 if (PyErr_Occurred()) SWIG_fail;
9635 }
9636 {
9637 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9638 }
9639 return resultobj;
9640 fail:
9641 return NULL;
9642 }
9643
9644
9645 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj = 0;
9647 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9648 int arg2 ;
9649 void *argp1 = 0 ;
9650 int res1 = 0 ;
9651 int val2 ;
9652 int ecode2 = 0 ;
9653 PyObject * obj0 = 0 ;
9654 PyObject * obj1 = 0 ;
9655 char * kwnames[] = {
9656 (char *) "self",(char *) "id", NULL
9657 };
9658
9659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9661 if (!SWIG_IsOK(res1)) {
9662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9663 }
9664 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9665 ecode2 = SWIG_AsVal_int(obj1, &val2);
9666 if (!SWIG_IsOK(ecode2)) {
9667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9668 }
9669 arg2 = static_cast< int >(val2);
9670 {
9671 PyThreadState* __tstate = wxPyBeginAllowThreads();
9672 (arg1)->SetId(arg2);
9673 wxPyEndAllowThreads(__tstate);
9674 if (PyErr_Occurred()) SWIG_fail;
9675 }
9676 resultobj = SWIG_Py_Void();
9677 return resultobj;
9678 fail:
9679 return NULL;
9680 }
9681
9682
9683 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9684 PyObject *resultobj = 0;
9685 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9686 int result;
9687 void *argp1 = 0 ;
9688 int res1 = 0 ;
9689 PyObject *swig_obj[1] ;
9690
9691 if (!args) SWIG_fail;
9692 swig_obj[0] = args;
9693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9694 if (!SWIG_IsOK(res1)) {
9695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9696 }
9697 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 result = (int)(arg1)->GetId();
9701 wxPyEndAllowThreads(__tstate);
9702 if (PyErr_Occurred()) SWIG_fail;
9703 }
9704 resultobj = SWIG_From_int(static_cast< int >(result));
9705 return resultobj;
9706 fail:
9707 return NULL;
9708 }
9709
9710
9711 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9712 PyObject *resultobj = 0;
9713 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9714 int arg2 ;
9715 void *argp1 = 0 ;
9716 int res1 = 0 ;
9717 int val2 ;
9718 int ecode2 = 0 ;
9719 PyObject * obj0 = 0 ;
9720 PyObject * obj1 = 0 ;
9721 char * kwnames[] = {
9722 (char *) "self",(char *) "comInt1", NULL
9723 };
9724
9725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9727 if (!SWIG_IsOK(res1)) {
9728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9729 }
9730 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9731 ecode2 = SWIG_AsVal_int(obj1, &val2);
9732 if (!SWIG_IsOK(ecode2)) {
9733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9734 }
9735 arg2 = static_cast< int >(val2);
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 (arg1)->SetCommandInt(arg2);
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 resultobj = SWIG_Py_Void();
9743 return resultobj;
9744 fail:
9745 return NULL;
9746 }
9747
9748
9749 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9750 PyObject *resultobj = 0;
9751 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9752 int result;
9753 void *argp1 = 0 ;
9754 int res1 = 0 ;
9755 PyObject *swig_obj[1] ;
9756
9757 if (!args) SWIG_fail;
9758 swig_obj[0] = args;
9759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9760 if (!SWIG_IsOK(res1)) {
9761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9762 }
9763 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 result = (int)(arg1)->GetCommandInt();
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 resultobj = SWIG_From_int(static_cast< int >(result));
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9778 PyObject *resultobj = 0;
9779 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9780 int arg2 ;
9781 void *argp1 = 0 ;
9782 int res1 = 0 ;
9783 int val2 ;
9784 int ecode2 = 0 ;
9785 PyObject * obj0 = 0 ;
9786 PyObject * obj1 = 0 ;
9787 char * kwnames[] = {
9788 (char *) "self",(char *) "comInt2", NULL
9789 };
9790
9791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9793 if (!SWIG_IsOK(res1)) {
9794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9795 }
9796 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9797 ecode2 = SWIG_AsVal_int(obj1, &val2);
9798 if (!SWIG_IsOK(ecode2)) {
9799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9800 }
9801 arg2 = static_cast< int >(val2);
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 (arg1)->SetCommandInt2(arg2);
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 resultobj = SWIG_Py_Void();
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9816 PyObject *resultobj = 0;
9817 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9818 int result;
9819 void *argp1 = 0 ;
9820 int res1 = 0 ;
9821 PyObject *swig_obj[1] ;
9822
9823 if (!args) SWIG_fail;
9824 swig_obj[0] = args;
9825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9826 if (!SWIG_IsOK(res1)) {
9827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9828 }
9829 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 result = (int)(arg1)->GetCommandInt2();
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 resultobj = SWIG_From_int(static_cast< int >(result));
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9844 PyObject *obj;
9845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9846 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9847 return SWIG_Py_Void();
9848 }
9849
9850 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9851 return SWIG_Python_InitShadowInstance(args);
9852 }
9853
9854 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9855 PyObject *resultobj = 0;
9856 int arg1 = (int) -1 ;
9857 int arg2 = (int) -1 ;
9858 wxGridCellCoords *result = 0 ;
9859 int val1 ;
9860 int ecode1 = 0 ;
9861 int val2 ;
9862 int ecode2 = 0 ;
9863 PyObject * obj0 = 0 ;
9864 PyObject * obj1 = 0 ;
9865 char * kwnames[] = {
9866 (char *) "r",(char *) "c", NULL
9867 };
9868
9869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9870 if (obj0) {
9871 ecode1 = SWIG_AsVal_int(obj0, &val1);
9872 if (!SWIG_IsOK(ecode1)) {
9873 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9874 }
9875 arg1 = static_cast< int >(val1);
9876 }
9877 if (obj1) {
9878 ecode2 = SWIG_AsVal_int(obj1, &val2);
9879 if (!SWIG_IsOK(ecode2)) {
9880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9881 }
9882 arg2 = static_cast< int >(val2);
9883 }
9884 {
9885 PyThreadState* __tstate = wxPyBeginAllowThreads();
9886 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 PyObject *resultobj = 0;
9899 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9900 void *argp1 = 0 ;
9901 int res1 = 0 ;
9902 PyObject *swig_obj[1] ;
9903
9904 if (!args) SWIG_fail;
9905 swig_obj[0] = args;
9906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9909 }
9910 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 delete arg1;
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 resultobj = SWIG_Py_Void();
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9926 PyObject *resultobj = 0;
9927 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9928 int result;
9929 void *argp1 = 0 ;
9930 int res1 = 0 ;
9931 PyObject *swig_obj[1] ;
9932
9933 if (!args) SWIG_fail;
9934 swig_obj[0] = args;
9935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9936 if (!SWIG_IsOK(res1)) {
9937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9938 }
9939 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 resultobj = SWIG_From_int(static_cast< int >(result));
9947 return resultobj;
9948 fail:
9949 return NULL;
9950 }
9951
9952
9953 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj = 0;
9955 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9956 int arg2 ;
9957 void *argp1 = 0 ;
9958 int res1 = 0 ;
9959 int val2 ;
9960 int ecode2 = 0 ;
9961 PyObject * obj0 = 0 ;
9962 PyObject * obj1 = 0 ;
9963 char * kwnames[] = {
9964 (char *) "self",(char *) "n", NULL
9965 };
9966
9967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
9968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9969 if (!SWIG_IsOK(res1)) {
9970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9971 }
9972 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9973 ecode2 = SWIG_AsVal_int(obj1, &val2);
9974 if (!SWIG_IsOK(ecode2)) {
9975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
9976 }
9977 arg2 = static_cast< int >(val2);
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 (arg1)->SetRow(arg2);
9981 wxPyEndAllowThreads(__tstate);
9982 if (PyErr_Occurred()) SWIG_fail;
9983 }
9984 resultobj = SWIG_Py_Void();
9985 return resultobj;
9986 fail:
9987 return NULL;
9988 }
9989
9990
9991 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9992 PyObject *resultobj = 0;
9993 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9994 int result;
9995 void *argp1 = 0 ;
9996 int res1 = 0 ;
9997 PyObject *swig_obj[1] ;
9998
9999 if (!args) SWIG_fail;
10000 swig_obj[0] = args;
10001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10002 if (!SWIG_IsOK(res1)) {
10003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10004 }
10005 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 resultobj = SWIG_From_int(static_cast< int >(result));
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10020 PyObject *resultobj = 0;
10021 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10022 int arg2 ;
10023 void *argp1 = 0 ;
10024 int res1 = 0 ;
10025 int val2 ;
10026 int ecode2 = 0 ;
10027 PyObject * obj0 = 0 ;
10028 PyObject * obj1 = 0 ;
10029 char * kwnames[] = {
10030 (char *) "self",(char *) "n", NULL
10031 };
10032
10033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10035 if (!SWIG_IsOK(res1)) {
10036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10037 }
10038 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10039 ecode2 = SWIG_AsVal_int(obj1, &val2);
10040 if (!SWIG_IsOK(ecode2)) {
10041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10042 }
10043 arg2 = static_cast< int >(val2);
10044 {
10045 PyThreadState* __tstate = wxPyBeginAllowThreads();
10046 (arg1)->SetCol(arg2);
10047 wxPyEndAllowThreads(__tstate);
10048 if (PyErr_Occurred()) SWIG_fail;
10049 }
10050 resultobj = SWIG_Py_Void();
10051 return resultobj;
10052 fail:
10053 return NULL;
10054 }
10055
10056
10057 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10058 PyObject *resultobj = 0;
10059 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10060 int arg2 ;
10061 int arg3 ;
10062 void *argp1 = 0 ;
10063 int res1 = 0 ;
10064 int val2 ;
10065 int ecode2 = 0 ;
10066 int val3 ;
10067 int ecode3 = 0 ;
10068 PyObject * obj0 = 0 ;
10069 PyObject * obj1 = 0 ;
10070 PyObject * obj2 = 0 ;
10071 char * kwnames[] = {
10072 (char *) "self",(char *) "row",(char *) "col", NULL
10073 };
10074
10075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10077 if (!SWIG_IsOK(res1)) {
10078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10079 }
10080 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10081 ecode2 = SWIG_AsVal_int(obj1, &val2);
10082 if (!SWIG_IsOK(ecode2)) {
10083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10084 }
10085 arg2 = static_cast< int >(val2);
10086 ecode3 = SWIG_AsVal_int(obj2, &val3);
10087 if (!SWIG_IsOK(ecode3)) {
10088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10089 }
10090 arg3 = static_cast< int >(val3);
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 (arg1)->Set(arg2,arg3);
10094 wxPyEndAllowThreads(__tstate);
10095 if (PyErr_Occurred()) SWIG_fail;
10096 }
10097 resultobj = SWIG_Py_Void();
10098 return resultobj;
10099 fail:
10100 return NULL;
10101 }
10102
10103
10104 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10105 PyObject *resultobj = 0;
10106 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10107 PyObject *arg2 = (PyObject *) 0 ;
10108 bool result;
10109 void *argp1 = 0 ;
10110 int res1 = 0 ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 char * kwnames[] = {
10114 (char *) "self",(char *) "other", NULL
10115 };
10116
10117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10119 if (!SWIG_IsOK(res1)) {
10120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10121 }
10122 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10123 arg2 = obj1;
10124 {
10125 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10126 if (PyErr_Occurred()) SWIG_fail;
10127 }
10128 {
10129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10130 }
10131 return resultobj;
10132 fail:
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj = 0;
10139 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10140 PyObject *arg2 = (PyObject *) 0 ;
10141 bool result;
10142 void *argp1 = 0 ;
10143 int res1 = 0 ;
10144 PyObject * obj0 = 0 ;
10145 PyObject * obj1 = 0 ;
10146 char * kwnames[] = {
10147 (char *) "self",(char *) "other", NULL
10148 };
10149
10150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10152 if (!SWIG_IsOK(res1)) {
10153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10154 }
10155 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10156 arg2 = obj1;
10157 {
10158 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 {
10162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10163 }
10164 return resultobj;
10165 fail:
10166 return NULL;
10167 }
10168
10169
10170 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10171 PyObject *resultobj = 0;
10172 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10173 PyObject *result = 0 ;
10174 void *argp1 = 0 ;
10175 int res1 = 0 ;
10176 PyObject *swig_obj[1] ;
10177
10178 if (!args) SWIG_fail;
10179 swig_obj[0] = args;
10180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10181 if (!SWIG_IsOK(res1)) {
10182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10183 }
10184 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10185 {
10186 PyThreadState* __tstate = wxPyBeginAllowThreads();
10187 result = (PyObject *)wxGridCellCoords_Get(arg1);
10188 wxPyEndAllowThreads(__tstate);
10189 if (PyErr_Occurred()) SWIG_fail;
10190 }
10191 resultobj = result;
10192 return resultobj;
10193 fail:
10194 return NULL;
10195 }
10196
10197
10198 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10199 PyObject *obj;
10200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10201 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10202 return SWIG_Py_Void();
10203 }
10204
10205 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10206 return SWIG_Python_InitShadowInstance(args);
10207 }
10208
10209 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10210 PyObject *resultobj = 0;
10211 wxWindow *arg1 = (wxWindow *) 0 ;
10212 int arg2 = (int) -1 ;
10213 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10214 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10215 wxSize const &arg4_defvalue = wxDefaultSize ;
10216 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10217 long arg5 = (long) wxWANTS_CHARS ;
10218 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10219 wxString *arg6 = (wxString *) &arg6_defvalue ;
10220 wxGrid *result = 0 ;
10221 void *argp1 = 0 ;
10222 int res1 = 0 ;
10223 int val2 ;
10224 int ecode2 = 0 ;
10225 wxPoint temp3 ;
10226 wxSize temp4 ;
10227 long val5 ;
10228 int ecode5 = 0 ;
10229 bool temp6 = false ;
10230 PyObject * obj0 = 0 ;
10231 PyObject * obj1 = 0 ;
10232 PyObject * obj2 = 0 ;
10233 PyObject * obj3 = 0 ;
10234 PyObject * obj4 = 0 ;
10235 PyObject * obj5 = 0 ;
10236 char * kwnames[] = {
10237 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10238 };
10239
10240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10242 if (!SWIG_IsOK(res1)) {
10243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10244 }
10245 arg1 = reinterpret_cast< wxWindow * >(argp1);
10246 if (obj1) {
10247 ecode2 = SWIG_AsVal_int(obj1, &val2);
10248 if (!SWIG_IsOK(ecode2)) {
10249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10250 }
10251 arg2 = static_cast< int >(val2);
10252 }
10253 if (obj2) {
10254 {
10255 arg3 = &temp3;
10256 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10257 }
10258 }
10259 if (obj3) {
10260 {
10261 arg4 = &temp4;
10262 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10263 }
10264 }
10265 if (obj4) {
10266 ecode5 = SWIG_AsVal_long(obj4, &val5);
10267 if (!SWIG_IsOK(ecode5)) {
10268 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10269 }
10270 arg5 = static_cast< long >(val5);
10271 }
10272 if (obj5) {
10273 {
10274 arg6 = wxString_in_helper(obj5);
10275 if (arg6 == NULL) SWIG_fail;
10276 temp6 = true;
10277 }
10278 }
10279 {
10280 if (!wxPyCheckForApp()) SWIG_fail;
10281 PyThreadState* __tstate = wxPyBeginAllowThreads();
10282 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10283 wxPyEndAllowThreads(__tstate);
10284 if (PyErr_Occurred()) SWIG_fail;
10285 }
10286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10287 {
10288 if (temp6)
10289 delete arg6;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp6)
10295 delete arg6;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10302 PyObject *resultobj = 0;
10303 wxGrid *result = 0 ;
10304
10305 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10306 {
10307 if (!wxPyCheckForApp()) SWIG_fail;
10308 PyThreadState* __tstate = wxPyBeginAllowThreads();
10309 result = (wxGrid *)new wxGrid();
10310 wxPyEndAllowThreads(__tstate);
10311 if (PyErr_Occurred()) SWIG_fail;
10312 }
10313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10314 return resultobj;
10315 fail:
10316 return NULL;
10317 }
10318
10319
10320 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10321 PyObject *resultobj = 0;
10322 wxGrid *arg1 = (wxGrid *) 0 ;
10323 wxWindow *arg2 = (wxWindow *) 0 ;
10324 int arg3 = (int) -1 ;
10325 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10326 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10327 wxSize const &arg5_defvalue = wxDefaultSize ;
10328 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10329 long arg6 = (long) wxWANTS_CHARS ;
10330 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10331 wxString *arg7 = (wxString *) &arg7_defvalue ;
10332 bool result;
10333 void *argp1 = 0 ;
10334 int res1 = 0 ;
10335 void *argp2 = 0 ;
10336 int res2 = 0 ;
10337 int val3 ;
10338 int ecode3 = 0 ;
10339 wxPoint temp4 ;
10340 wxSize temp5 ;
10341 long val6 ;
10342 int ecode6 = 0 ;
10343 bool temp7 = false ;
10344 PyObject * obj0 = 0 ;
10345 PyObject * obj1 = 0 ;
10346 PyObject * obj2 = 0 ;
10347 PyObject * obj3 = 0 ;
10348 PyObject * obj4 = 0 ;
10349 PyObject * obj5 = 0 ;
10350 PyObject * obj6 = 0 ;
10351 char * kwnames[] = {
10352 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10353 };
10354
10355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10357 if (!SWIG_IsOK(res1)) {
10358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10359 }
10360 arg1 = reinterpret_cast< wxGrid * >(argp1);
10361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10362 if (!SWIG_IsOK(res2)) {
10363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10364 }
10365 arg2 = reinterpret_cast< wxWindow * >(argp2);
10366 if (obj2) {
10367 ecode3 = SWIG_AsVal_int(obj2, &val3);
10368 if (!SWIG_IsOK(ecode3)) {
10369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10370 }
10371 arg3 = static_cast< int >(val3);
10372 }
10373 if (obj3) {
10374 {
10375 arg4 = &temp4;
10376 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10377 }
10378 }
10379 if (obj4) {
10380 {
10381 arg5 = &temp5;
10382 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10383 }
10384 }
10385 if (obj5) {
10386 ecode6 = SWIG_AsVal_long(obj5, &val6);
10387 if (!SWIG_IsOK(ecode6)) {
10388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10389 }
10390 arg6 = static_cast< long >(val6);
10391 }
10392 if (obj6) {
10393 {
10394 arg7 = wxString_in_helper(obj6);
10395 if (arg7 == NULL) SWIG_fail;
10396 temp7 = true;
10397 }
10398 }
10399 {
10400 PyThreadState* __tstate = wxPyBeginAllowThreads();
10401 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10402 wxPyEndAllowThreads(__tstate);
10403 if (PyErr_Occurred()) SWIG_fail;
10404 }
10405 {
10406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10407 }
10408 {
10409 if (temp7)
10410 delete arg7;
10411 }
10412 return resultobj;
10413 fail:
10414 {
10415 if (temp7)
10416 delete arg7;
10417 }
10418 return NULL;
10419 }
10420
10421
10422 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10423 PyObject *resultobj = 0;
10424 wxGrid *arg1 = (wxGrid *) 0 ;
10425 int arg2 ;
10426 int arg3 ;
10427 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10428 bool result;
10429 void *argp1 = 0 ;
10430 int res1 = 0 ;
10431 int val2 ;
10432 int ecode2 = 0 ;
10433 int val3 ;
10434 int ecode3 = 0 ;
10435 int val4 ;
10436 int ecode4 = 0 ;
10437 PyObject * obj0 = 0 ;
10438 PyObject * obj1 = 0 ;
10439 PyObject * obj2 = 0 ;
10440 PyObject * obj3 = 0 ;
10441 char * kwnames[] = {
10442 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10443 };
10444
10445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10447 if (!SWIG_IsOK(res1)) {
10448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10449 }
10450 arg1 = reinterpret_cast< wxGrid * >(argp1);
10451 ecode2 = SWIG_AsVal_int(obj1, &val2);
10452 if (!SWIG_IsOK(ecode2)) {
10453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10454 }
10455 arg2 = static_cast< int >(val2);
10456 ecode3 = SWIG_AsVal_int(obj2, &val3);
10457 if (!SWIG_IsOK(ecode3)) {
10458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10459 }
10460 arg3 = static_cast< int >(val3);
10461 if (obj3) {
10462 ecode4 = SWIG_AsVal_int(obj3, &val4);
10463 if (!SWIG_IsOK(ecode4)) {
10464 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10465 }
10466 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10467 }
10468 {
10469 PyThreadState* __tstate = wxPyBeginAllowThreads();
10470 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10471 wxPyEndAllowThreads(__tstate);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 {
10475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10476 }
10477 return resultobj;
10478 fail:
10479 return NULL;
10480 }
10481
10482
10483 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10484 PyObject *resultobj = 0;
10485 wxGrid *arg1 = (wxGrid *) 0 ;
10486 WXGRIDSELECTIONMODES arg2 ;
10487 void *argp1 = 0 ;
10488 int res1 = 0 ;
10489 int val2 ;
10490 int ecode2 = 0 ;
10491 PyObject * obj0 = 0 ;
10492 PyObject * obj1 = 0 ;
10493 char * kwnames[] = {
10494 (char *) "self",(char *) "selmode", NULL
10495 };
10496
10497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10499 if (!SWIG_IsOK(res1)) {
10500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10501 }
10502 arg1 = reinterpret_cast< wxGrid * >(argp1);
10503 ecode2 = SWIG_AsVal_int(obj1, &val2);
10504 if (!SWIG_IsOK(ecode2)) {
10505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10506 }
10507 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 (arg1)->SetSelectionMode(arg2);
10511 wxPyEndAllowThreads(__tstate);
10512 if (PyErr_Occurred()) SWIG_fail;
10513 }
10514 resultobj = SWIG_Py_Void();
10515 return resultobj;
10516 fail:
10517 return NULL;
10518 }
10519
10520
10521 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10522 PyObject *resultobj = 0;
10523 wxGrid *arg1 = (wxGrid *) 0 ;
10524 WXGRIDSELECTIONMODES result;
10525 void *argp1 = 0 ;
10526 int res1 = 0 ;
10527 PyObject *swig_obj[1] ;
10528
10529 if (!args) SWIG_fail;
10530 swig_obj[0] = args;
10531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10534 }
10535 arg1 = reinterpret_cast< wxGrid * >(argp1);
10536 {
10537 PyThreadState* __tstate = wxPyBeginAllowThreads();
10538 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10539 wxPyEndAllowThreads(__tstate);
10540 if (PyErr_Occurred()) SWIG_fail;
10541 }
10542 resultobj = SWIG_From_int(static_cast< int >(result));
10543 return resultobj;
10544 fail:
10545 return NULL;
10546 }
10547
10548
10549 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10550 PyObject *resultobj = 0;
10551 wxGrid *arg1 = (wxGrid *) 0 ;
10552 int result;
10553 void *argp1 = 0 ;
10554 int res1 = 0 ;
10555 PyObject *swig_obj[1] ;
10556
10557 if (!args) SWIG_fail;
10558 swig_obj[0] = args;
10559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10560 if (!SWIG_IsOK(res1)) {
10561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10562 }
10563 arg1 = reinterpret_cast< wxGrid * >(argp1);
10564 {
10565 PyThreadState* __tstate = wxPyBeginAllowThreads();
10566 result = (int)(arg1)->GetNumberRows();
10567 wxPyEndAllowThreads(__tstate);
10568 if (PyErr_Occurred()) SWIG_fail;
10569 }
10570 resultobj = SWIG_From_int(static_cast< int >(result));
10571 return resultobj;
10572 fail:
10573 return NULL;
10574 }
10575
10576
10577 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10578 PyObject *resultobj = 0;
10579 wxGrid *arg1 = (wxGrid *) 0 ;
10580 int result;
10581 void *argp1 = 0 ;
10582 int res1 = 0 ;
10583 PyObject *swig_obj[1] ;
10584
10585 if (!args) SWIG_fail;
10586 swig_obj[0] = args;
10587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10588 if (!SWIG_IsOK(res1)) {
10589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10590 }
10591 arg1 = reinterpret_cast< wxGrid * >(argp1);
10592 {
10593 PyThreadState* __tstate = wxPyBeginAllowThreads();
10594 result = (int)(arg1)->GetNumberCols();
10595 wxPyEndAllowThreads(__tstate);
10596 if (PyErr_Occurred()) SWIG_fail;
10597 }
10598 resultobj = SWIG_From_int(static_cast< int >(result));
10599 return resultobj;
10600 fail:
10601 return NULL;
10602 }
10603
10604
10605 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10606 PyObject *resultobj = 0;
10607 wxGrid *arg1 = (wxGrid *) 0 ;
10608 wxGridTableMessage *arg2 = 0 ;
10609 bool result;
10610 void *argp1 = 0 ;
10611 int res1 = 0 ;
10612 void *argp2 = 0 ;
10613 int res2 = 0 ;
10614 PyObject * obj0 = 0 ;
10615 PyObject * obj1 = 0 ;
10616 char * kwnames[] = {
10617 (char *) "self",(char *)"arg2", NULL
10618 };
10619
10620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10622 if (!SWIG_IsOK(res1)) {
10623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10624 }
10625 arg1 = reinterpret_cast< wxGrid * >(argp1);
10626 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10627 if (!SWIG_IsOK(res2)) {
10628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10629 }
10630 if (!argp2) {
10631 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10632 }
10633 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10634 {
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10637 wxPyEndAllowThreads(__tstate);
10638 if (PyErr_Occurred()) SWIG_fail;
10639 }
10640 {
10641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10642 }
10643 return resultobj;
10644 fail:
10645 return NULL;
10646 }
10647
10648
10649 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10650 PyObject *resultobj = 0;
10651 wxGrid *arg1 = (wxGrid *) 0 ;
10652 wxGridTableBase *result = 0 ;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 PyObject *swig_obj[1] ;
10656
10657 if (!args) SWIG_fail;
10658 swig_obj[0] = args;
10659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10660 if (!SWIG_IsOK(res1)) {
10661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10662 }
10663 arg1 = reinterpret_cast< wxGrid * >(argp1);
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10672 }
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj = 0;
10681 wxGrid *arg1 = (wxGrid *) 0 ;
10682 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10683 bool arg3 = (bool) false ;
10684 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10685 bool result;
10686 void *argp1 = 0 ;
10687 int res1 = 0 ;
10688 int res2 = 0 ;
10689 bool val3 ;
10690 int ecode3 = 0 ;
10691 int val4 ;
10692 int ecode4 = 0 ;
10693 PyObject * obj0 = 0 ;
10694 PyObject * obj1 = 0 ;
10695 PyObject * obj2 = 0 ;
10696 PyObject * obj3 = 0 ;
10697 char * kwnames[] = {
10698 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10699 };
10700
10701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10703 if (!SWIG_IsOK(res1)) {
10704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10705 }
10706 arg1 = reinterpret_cast< wxGrid * >(argp1);
10707 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10708 if (!SWIG_IsOK(res2)) {
10709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10710 }
10711 if (obj2) {
10712 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10713 if (!SWIG_IsOK(ecode3)) {
10714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10715 }
10716 arg3 = static_cast< bool >(val3);
10717 }
10718 if (obj3) {
10719 ecode4 = SWIG_AsVal_int(obj3, &val4);
10720 if (!SWIG_IsOK(ecode4)) {
10721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10722 }
10723 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10724 }
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10728 wxPyEndAllowThreads(__tstate);
10729 if (PyErr_Occurred()) SWIG_fail;
10730 }
10731 {
10732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10733 }
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10741 PyObject *resultobj = 0;
10742 wxGrid *arg1 = (wxGrid *) 0 ;
10743 void *argp1 = 0 ;
10744 int res1 = 0 ;
10745 PyObject *swig_obj[1] ;
10746
10747 if (!args) SWIG_fail;
10748 swig_obj[0] = args;
10749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10750 if (!SWIG_IsOK(res1)) {
10751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10752 }
10753 arg1 = reinterpret_cast< wxGrid * >(argp1);
10754 {
10755 PyThreadState* __tstate = wxPyBeginAllowThreads();
10756 (arg1)->ClearGrid();
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 resultobj = SWIG_Py_Void();
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj = 0;
10769 wxGrid *arg1 = (wxGrid *) 0 ;
10770 int arg2 = (int) 0 ;
10771 int arg3 = (int) 1 ;
10772 bool arg4 = (bool) true ;
10773 bool result;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 int val2 ;
10777 int ecode2 = 0 ;
10778 int val3 ;
10779 int ecode3 = 0 ;
10780 bool val4 ;
10781 int ecode4 = 0 ;
10782 PyObject * obj0 = 0 ;
10783 PyObject * obj1 = 0 ;
10784 PyObject * obj2 = 0 ;
10785 PyObject * obj3 = 0 ;
10786 char * kwnames[] = {
10787 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10788 };
10789
10790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10792 if (!SWIG_IsOK(res1)) {
10793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10794 }
10795 arg1 = reinterpret_cast< wxGrid * >(argp1);
10796 if (obj1) {
10797 ecode2 = SWIG_AsVal_int(obj1, &val2);
10798 if (!SWIG_IsOK(ecode2)) {
10799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10800 }
10801 arg2 = static_cast< int >(val2);
10802 }
10803 if (obj2) {
10804 ecode3 = SWIG_AsVal_int(obj2, &val3);
10805 if (!SWIG_IsOK(ecode3)) {
10806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10807 }
10808 arg3 = static_cast< int >(val3);
10809 }
10810 if (obj3) {
10811 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10812 if (!SWIG_IsOK(ecode4)) {
10813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10814 }
10815 arg4 = static_cast< bool >(val4);
10816 }
10817 {
10818 PyThreadState* __tstate = wxPyBeginAllowThreads();
10819 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 {
10824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10825 }
10826 return resultobj;
10827 fail:
10828 return NULL;
10829 }
10830
10831
10832 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10833 PyObject *resultobj = 0;
10834 wxGrid *arg1 = (wxGrid *) 0 ;
10835 int arg2 = (int) 1 ;
10836 bool arg3 = (bool) true ;
10837 bool result;
10838 void *argp1 = 0 ;
10839 int res1 = 0 ;
10840 int val2 ;
10841 int ecode2 = 0 ;
10842 bool val3 ;
10843 int ecode3 = 0 ;
10844 PyObject * obj0 = 0 ;
10845 PyObject * obj1 = 0 ;
10846 PyObject * obj2 = 0 ;
10847 char * kwnames[] = {
10848 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10849 };
10850
10851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10853 if (!SWIG_IsOK(res1)) {
10854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10855 }
10856 arg1 = reinterpret_cast< wxGrid * >(argp1);
10857 if (obj1) {
10858 ecode2 = SWIG_AsVal_int(obj1, &val2);
10859 if (!SWIG_IsOK(ecode2)) {
10860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10861 }
10862 arg2 = static_cast< int >(val2);
10863 }
10864 if (obj2) {
10865 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10866 if (!SWIG_IsOK(ecode3)) {
10867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10868 }
10869 arg3 = static_cast< bool >(val3);
10870 }
10871 {
10872 PyThreadState* __tstate = wxPyBeginAllowThreads();
10873 result = (bool)(arg1)->AppendRows(arg2,arg3);
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 {
10878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10879 }
10880 return resultobj;
10881 fail:
10882 return NULL;
10883 }
10884
10885
10886 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10887 PyObject *resultobj = 0;
10888 wxGrid *arg1 = (wxGrid *) 0 ;
10889 int arg2 = (int) 0 ;
10890 int arg3 = (int) 1 ;
10891 bool arg4 = (bool) true ;
10892 bool result;
10893 void *argp1 = 0 ;
10894 int res1 = 0 ;
10895 int val2 ;
10896 int ecode2 = 0 ;
10897 int val3 ;
10898 int ecode3 = 0 ;
10899 bool val4 ;
10900 int ecode4 = 0 ;
10901 PyObject * obj0 = 0 ;
10902 PyObject * obj1 = 0 ;
10903 PyObject * obj2 = 0 ;
10904 PyObject * obj3 = 0 ;
10905 char * kwnames[] = {
10906 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10907 };
10908
10909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10911 if (!SWIG_IsOK(res1)) {
10912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10913 }
10914 arg1 = reinterpret_cast< wxGrid * >(argp1);
10915 if (obj1) {
10916 ecode2 = SWIG_AsVal_int(obj1, &val2);
10917 if (!SWIG_IsOK(ecode2)) {
10918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10919 }
10920 arg2 = static_cast< int >(val2);
10921 }
10922 if (obj2) {
10923 ecode3 = SWIG_AsVal_int(obj2, &val3);
10924 if (!SWIG_IsOK(ecode3)) {
10925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10926 }
10927 arg3 = static_cast< int >(val3);
10928 }
10929 if (obj3) {
10930 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10931 if (!SWIG_IsOK(ecode4)) {
10932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10933 }
10934 arg4 = static_cast< bool >(val4);
10935 }
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10939 wxPyEndAllowThreads(__tstate);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 {
10943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10944 }
10945 return resultobj;
10946 fail:
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxGrid *arg1 = (wxGrid *) 0 ;
10954 int arg2 = (int) 0 ;
10955 int arg3 = (int) 1 ;
10956 bool arg4 = (bool) true ;
10957 bool result;
10958 void *argp1 = 0 ;
10959 int res1 = 0 ;
10960 int val2 ;
10961 int ecode2 = 0 ;
10962 int val3 ;
10963 int ecode3 = 0 ;
10964 bool val4 ;
10965 int ecode4 = 0 ;
10966 PyObject * obj0 = 0 ;
10967 PyObject * obj1 = 0 ;
10968 PyObject * obj2 = 0 ;
10969 PyObject * obj3 = 0 ;
10970 char * kwnames[] = {
10971 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10972 };
10973
10974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10976 if (!SWIG_IsOK(res1)) {
10977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10978 }
10979 arg1 = reinterpret_cast< wxGrid * >(argp1);
10980 if (obj1) {
10981 ecode2 = SWIG_AsVal_int(obj1, &val2);
10982 if (!SWIG_IsOK(ecode2)) {
10983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10984 }
10985 arg2 = static_cast< int >(val2);
10986 }
10987 if (obj2) {
10988 ecode3 = SWIG_AsVal_int(obj2, &val3);
10989 if (!SWIG_IsOK(ecode3)) {
10990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10991 }
10992 arg3 = static_cast< int >(val3);
10993 }
10994 if (obj3) {
10995 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10996 if (!SWIG_IsOK(ecode4)) {
10997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
10998 }
10999 arg4 = static_cast< bool >(val4);
11000 }
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 {
11008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11009 }
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj = 0;
11018 wxGrid *arg1 = (wxGrid *) 0 ;
11019 int arg2 = (int) 1 ;
11020 bool arg3 = (bool) true ;
11021 bool result;
11022 void *argp1 = 0 ;
11023 int res1 = 0 ;
11024 int val2 ;
11025 int ecode2 = 0 ;
11026 bool val3 ;
11027 int ecode3 = 0 ;
11028 PyObject * obj0 = 0 ;
11029 PyObject * obj1 = 0 ;
11030 PyObject * obj2 = 0 ;
11031 char * kwnames[] = {
11032 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11033 };
11034
11035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11037 if (!SWIG_IsOK(res1)) {
11038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11039 }
11040 arg1 = reinterpret_cast< wxGrid * >(argp1);
11041 if (obj1) {
11042 ecode2 = SWIG_AsVal_int(obj1, &val2);
11043 if (!SWIG_IsOK(ecode2)) {
11044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11045 }
11046 arg2 = static_cast< int >(val2);
11047 }
11048 if (obj2) {
11049 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11050 if (!SWIG_IsOK(ecode3)) {
11051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11052 }
11053 arg3 = static_cast< bool >(val3);
11054 }
11055 {
11056 PyThreadState* __tstate = wxPyBeginAllowThreads();
11057 result = (bool)(arg1)->AppendCols(arg2,arg3);
11058 wxPyEndAllowThreads(__tstate);
11059 if (PyErr_Occurred()) SWIG_fail;
11060 }
11061 {
11062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11063 }
11064 return resultobj;
11065 fail:
11066 return NULL;
11067 }
11068
11069
11070 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11071 PyObject *resultobj = 0;
11072 wxGrid *arg1 = (wxGrid *) 0 ;
11073 int arg2 = (int) 0 ;
11074 int arg3 = (int) 1 ;
11075 bool arg4 = (bool) true ;
11076 bool result;
11077 void *argp1 = 0 ;
11078 int res1 = 0 ;
11079 int val2 ;
11080 int ecode2 = 0 ;
11081 int val3 ;
11082 int ecode3 = 0 ;
11083 bool val4 ;
11084 int ecode4 = 0 ;
11085 PyObject * obj0 = 0 ;
11086 PyObject * obj1 = 0 ;
11087 PyObject * obj2 = 0 ;
11088 PyObject * obj3 = 0 ;
11089 char * kwnames[] = {
11090 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11091 };
11092
11093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11095 if (!SWIG_IsOK(res1)) {
11096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11097 }
11098 arg1 = reinterpret_cast< wxGrid * >(argp1);
11099 if (obj1) {
11100 ecode2 = SWIG_AsVal_int(obj1, &val2);
11101 if (!SWIG_IsOK(ecode2)) {
11102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11103 }
11104 arg2 = static_cast< int >(val2);
11105 }
11106 if (obj2) {
11107 ecode3 = SWIG_AsVal_int(obj2, &val3);
11108 if (!SWIG_IsOK(ecode3)) {
11109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11110 }
11111 arg3 = static_cast< int >(val3);
11112 }
11113 if (obj3) {
11114 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11115 if (!SWIG_IsOK(ecode4)) {
11116 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11117 }
11118 arg4 = static_cast< bool >(val4);
11119 }
11120 {
11121 PyThreadState* __tstate = wxPyBeginAllowThreads();
11122 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11123 wxPyEndAllowThreads(__tstate);
11124 if (PyErr_Occurred()) SWIG_fail;
11125 }
11126 {
11127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11128 }
11129 return resultobj;
11130 fail:
11131 return NULL;
11132 }
11133
11134
11135 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj = 0;
11137 wxGrid *arg1 = (wxGrid *) 0 ;
11138 wxDC *arg2 = 0 ;
11139 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11140 void *argp1 = 0 ;
11141 int res1 = 0 ;
11142 void *argp2 = 0 ;
11143 int res2 = 0 ;
11144 void *argp3 = 0 ;
11145 int res3 = 0 ;
11146 PyObject * obj0 = 0 ;
11147 PyObject * obj1 = 0 ;
11148 PyObject * obj2 = 0 ;
11149 char * kwnames[] = {
11150 (char *) "self",(char *) "dc",(char *) "attr", NULL
11151 };
11152
11153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11155 if (!SWIG_IsOK(res1)) {
11156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11157 }
11158 arg1 = reinterpret_cast< wxGrid * >(argp1);
11159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11160 if (!SWIG_IsOK(res2)) {
11161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11162 }
11163 if (!argp2) {
11164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11165 }
11166 arg2 = reinterpret_cast< wxDC * >(argp2);
11167 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11168 if (!SWIG_IsOK(res3)) {
11169 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11170 }
11171 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11175 wxPyEndAllowThreads(__tstate);
11176 if (PyErr_Occurred()) SWIG_fail;
11177 }
11178 resultobj = SWIG_Py_Void();
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11186 PyObject *resultobj = 0;
11187 wxGrid *arg1 = (wxGrid *) 0 ;
11188 wxDC *arg2 = 0 ;
11189 wxString *arg3 = 0 ;
11190 wxRect *arg4 = 0 ;
11191 int arg5 = (int) wxLEFT ;
11192 int arg6 = (int) wxTOP ;
11193 int arg7 = (int) wxHORIZONTAL ;
11194 void *argp1 = 0 ;
11195 int res1 = 0 ;
11196 void *argp2 = 0 ;
11197 int res2 = 0 ;
11198 bool temp3 = false ;
11199 wxRect temp4 ;
11200 int val5 ;
11201 int ecode5 = 0 ;
11202 int val6 ;
11203 int ecode6 = 0 ;
11204 int val7 ;
11205 int ecode7 = 0 ;
11206 PyObject * obj0 = 0 ;
11207 PyObject * obj1 = 0 ;
11208 PyObject * obj2 = 0 ;
11209 PyObject * obj3 = 0 ;
11210 PyObject * obj4 = 0 ;
11211 PyObject * obj5 = 0 ;
11212 PyObject * obj6 = 0 ;
11213 char * kwnames[] = {
11214 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11215 };
11216
11217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11219 if (!SWIG_IsOK(res1)) {
11220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11221 }
11222 arg1 = reinterpret_cast< wxGrid * >(argp1);
11223 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11224 if (!SWIG_IsOK(res2)) {
11225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11226 }
11227 if (!argp2) {
11228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11229 }
11230 arg2 = reinterpret_cast< wxDC * >(argp2);
11231 {
11232 arg3 = wxString_in_helper(obj2);
11233 if (arg3 == NULL) SWIG_fail;
11234 temp3 = true;
11235 }
11236 {
11237 arg4 = &temp4;
11238 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11239 }
11240 if (obj4) {
11241 ecode5 = SWIG_AsVal_int(obj4, &val5);
11242 if (!SWIG_IsOK(ecode5)) {
11243 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11244 }
11245 arg5 = static_cast< int >(val5);
11246 }
11247 if (obj5) {
11248 ecode6 = SWIG_AsVal_int(obj5, &val6);
11249 if (!SWIG_IsOK(ecode6)) {
11250 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11251 }
11252 arg6 = static_cast< int >(val6);
11253 }
11254 if (obj6) {
11255 ecode7 = SWIG_AsVal_int(obj6, &val7);
11256 if (!SWIG_IsOK(ecode7)) {
11257 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11258 }
11259 arg7 = static_cast< int >(val7);
11260 }
11261 {
11262 PyThreadState* __tstate = wxPyBeginAllowThreads();
11263 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11264 wxPyEndAllowThreads(__tstate);
11265 if (PyErr_Occurred()) SWIG_fail;
11266 }
11267 resultobj = SWIG_Py_Void();
11268 {
11269 if (temp3)
11270 delete arg3;
11271 }
11272 return resultobj;
11273 fail:
11274 {
11275 if (temp3)
11276 delete arg3;
11277 }
11278 return NULL;
11279 }
11280
11281
11282 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11283 PyObject *resultobj = 0;
11284 wxGrid *arg1 = (wxGrid *) 0 ;
11285 wxDC *arg2 = 0 ;
11286 wxArrayString *arg3 = 0 ;
11287 long *arg4 = (long *) 0 ;
11288 long *arg5 = (long *) 0 ;
11289 void *argp1 = 0 ;
11290 int res1 = 0 ;
11291 void *argp2 = 0 ;
11292 int res2 = 0 ;
11293 bool temp3 = false ;
11294 long temp4 ;
11295 int res4 = SWIG_TMPOBJ ;
11296 long temp5 ;
11297 int res5 = SWIG_TMPOBJ ;
11298 PyObject * obj0 = 0 ;
11299 PyObject * obj1 = 0 ;
11300 PyObject * obj2 = 0 ;
11301 char * kwnames[] = {
11302 (char *) "self",(char *) "dc",(char *) "lines", NULL
11303 };
11304
11305 arg4 = &temp4;
11306 arg5 = &temp5;
11307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11309 if (!SWIG_IsOK(res1)) {
11310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11311 }
11312 arg1 = reinterpret_cast< wxGrid * >(argp1);
11313 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11314 if (!SWIG_IsOK(res2)) {
11315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11316 }
11317 if (!argp2) {
11318 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11319 }
11320 arg2 = reinterpret_cast< wxDC * >(argp2);
11321 {
11322 if (! PySequence_Check(obj2)) {
11323 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11324 SWIG_fail;
11325 }
11326 arg3 = new wxArrayString;
11327 temp3 = true;
11328 int i, len=PySequence_Length(obj2);
11329 for (i=0; i<len; i++) {
11330 PyObject* item = PySequence_GetItem(obj2, i);
11331 wxString* s = wxString_in_helper(item);
11332 if (PyErr_Occurred()) SWIG_fail;
11333 arg3->Add(*s);
11334 delete s;
11335 Py_DECREF(item);
11336 }
11337 }
11338 {
11339 PyThreadState* __tstate = wxPyBeginAllowThreads();
11340 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11341 wxPyEndAllowThreads(__tstate);
11342 if (PyErr_Occurred()) SWIG_fail;
11343 }
11344 resultobj = SWIG_Py_Void();
11345 if (SWIG_IsTmpObj(res4)) {
11346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11347 } else {
11348 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11350 }
11351 if (SWIG_IsTmpObj(res5)) {
11352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11353 } else {
11354 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11356 }
11357 {
11358 if (temp3) delete arg3;
11359 }
11360 return resultobj;
11361 fail:
11362 {
11363 if (temp3) delete arg3;
11364 }
11365 return NULL;
11366 }
11367
11368
11369 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11370 PyObject *resultobj = 0;
11371 wxGrid *arg1 = (wxGrid *) 0 ;
11372 void *argp1 = 0 ;
11373 int res1 = 0 ;
11374 PyObject *swig_obj[1] ;
11375
11376 if (!args) SWIG_fail;
11377 swig_obj[0] = args;
11378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11379 if (!SWIG_IsOK(res1)) {
11380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11381 }
11382 arg1 = reinterpret_cast< wxGrid * >(argp1);
11383 {
11384 PyThreadState* __tstate = wxPyBeginAllowThreads();
11385 (arg1)->BeginBatch();
11386 wxPyEndAllowThreads(__tstate);
11387 if (PyErr_Occurred()) SWIG_fail;
11388 }
11389 resultobj = SWIG_Py_Void();
11390 return resultobj;
11391 fail:
11392 return NULL;
11393 }
11394
11395
11396 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11397 PyObject *resultobj = 0;
11398 wxGrid *arg1 = (wxGrid *) 0 ;
11399 void *argp1 = 0 ;
11400 int res1 = 0 ;
11401 PyObject *swig_obj[1] ;
11402
11403 if (!args) SWIG_fail;
11404 swig_obj[0] = args;
11405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11406 if (!SWIG_IsOK(res1)) {
11407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11408 }
11409 arg1 = reinterpret_cast< wxGrid * >(argp1);
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 (arg1)->EndBatch();
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 resultobj = SWIG_Py_Void();
11417 return resultobj;
11418 fail:
11419 return NULL;
11420 }
11421
11422
11423 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11424 PyObject *resultobj = 0;
11425 wxGrid *arg1 = (wxGrid *) 0 ;
11426 int result;
11427 void *argp1 = 0 ;
11428 int res1 = 0 ;
11429 PyObject *swig_obj[1] ;
11430
11431 if (!args) SWIG_fail;
11432 swig_obj[0] = args;
11433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11434 if (!SWIG_IsOK(res1)) {
11435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11436 }
11437 arg1 = reinterpret_cast< wxGrid * >(argp1);
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 result = (int)(arg1)->GetBatchCount();
11441 wxPyEndAllowThreads(__tstate);
11442 if (PyErr_Occurred()) SWIG_fail;
11443 }
11444 resultobj = SWIG_From_int(static_cast< int >(result));
11445 return resultobj;
11446 fail:
11447 return NULL;
11448 }
11449
11450
11451 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11452 PyObject *resultobj = 0;
11453 wxGrid *arg1 = (wxGrid *) 0 ;
11454 void *argp1 = 0 ;
11455 int res1 = 0 ;
11456 PyObject *swig_obj[1] ;
11457
11458 if (!args) SWIG_fail;
11459 swig_obj[0] = args;
11460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11461 if (!SWIG_IsOK(res1)) {
11462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11463 }
11464 arg1 = reinterpret_cast< wxGrid * >(argp1);
11465 {
11466 PyThreadState* __tstate = wxPyBeginAllowThreads();
11467 (arg1)->ForceRefresh();
11468 wxPyEndAllowThreads(__tstate);
11469 if (PyErr_Occurred()) SWIG_fail;
11470 }
11471 resultobj = SWIG_Py_Void();
11472 return resultobj;
11473 fail:
11474 return NULL;
11475 }
11476
11477
11478 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11479 PyObject *resultobj = 0;
11480 wxGrid *arg1 = (wxGrid *) 0 ;
11481 bool result;
11482 void *argp1 = 0 ;
11483 int res1 = 0 ;
11484 PyObject *swig_obj[1] ;
11485
11486 if (!args) SWIG_fail;
11487 swig_obj[0] = args;
11488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11489 if (!SWIG_IsOK(res1)) {
11490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11491 }
11492 arg1 = reinterpret_cast< wxGrid * >(argp1);
11493 {
11494 PyThreadState* __tstate = wxPyBeginAllowThreads();
11495 result = (bool)(arg1)->IsEditable();
11496 wxPyEndAllowThreads(__tstate);
11497 if (PyErr_Occurred()) SWIG_fail;
11498 }
11499 {
11500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11501 }
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11509 PyObject *resultobj = 0;
11510 wxGrid *arg1 = (wxGrid *) 0 ;
11511 bool arg2 ;
11512 void *argp1 = 0 ;
11513 int res1 = 0 ;
11514 bool val2 ;
11515 int ecode2 = 0 ;
11516 PyObject * obj0 = 0 ;
11517 PyObject * obj1 = 0 ;
11518 char * kwnames[] = {
11519 (char *) "self",(char *) "edit", NULL
11520 };
11521
11522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11524 if (!SWIG_IsOK(res1)) {
11525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11526 }
11527 arg1 = reinterpret_cast< wxGrid * >(argp1);
11528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11529 if (!SWIG_IsOK(ecode2)) {
11530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11531 }
11532 arg2 = static_cast< bool >(val2);
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 (arg1)->EnableEditing(arg2);
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 resultobj = SWIG_Py_Void();
11540 return resultobj;
11541 fail:
11542 return NULL;
11543 }
11544
11545
11546 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11547 PyObject *resultobj = 0;
11548 wxGrid *arg1 = (wxGrid *) 0 ;
11549 bool arg2 = (bool) true ;
11550 void *argp1 = 0 ;
11551 int res1 = 0 ;
11552 bool val2 ;
11553 int ecode2 = 0 ;
11554 PyObject * obj0 = 0 ;
11555 PyObject * obj1 = 0 ;
11556 char * kwnames[] = {
11557 (char *) "self",(char *) "enable", NULL
11558 };
11559
11560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11562 if (!SWIG_IsOK(res1)) {
11563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11564 }
11565 arg1 = reinterpret_cast< wxGrid * >(argp1);
11566 if (obj1) {
11567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11568 if (!SWIG_IsOK(ecode2)) {
11569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11570 }
11571 arg2 = static_cast< bool >(val2);
11572 }
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 (arg1)->EnableCellEditControl(arg2);
11576 wxPyEndAllowThreads(__tstate);
11577 if (PyErr_Occurred()) SWIG_fail;
11578 }
11579 resultobj = SWIG_Py_Void();
11580 return resultobj;
11581 fail:
11582 return NULL;
11583 }
11584
11585
11586 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11587 PyObject *resultobj = 0;
11588 wxGrid *arg1 = (wxGrid *) 0 ;
11589 void *argp1 = 0 ;
11590 int res1 = 0 ;
11591 PyObject *swig_obj[1] ;
11592
11593 if (!args) SWIG_fail;
11594 swig_obj[0] = args;
11595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11596 if (!SWIG_IsOK(res1)) {
11597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11598 }
11599 arg1 = reinterpret_cast< wxGrid * >(argp1);
11600 {
11601 PyThreadState* __tstate = wxPyBeginAllowThreads();
11602 (arg1)->DisableCellEditControl();
11603 wxPyEndAllowThreads(__tstate);
11604 if (PyErr_Occurred()) SWIG_fail;
11605 }
11606 resultobj = SWIG_Py_Void();
11607 return resultobj;
11608 fail:
11609 return NULL;
11610 }
11611
11612
11613 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11614 PyObject *resultobj = 0;
11615 wxGrid *arg1 = (wxGrid *) 0 ;
11616 bool result;
11617 void *argp1 = 0 ;
11618 int res1 = 0 ;
11619 PyObject *swig_obj[1] ;
11620
11621 if (!args) SWIG_fail;
11622 swig_obj[0] = args;
11623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11624 if (!SWIG_IsOK(res1)) {
11625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11626 }
11627 arg1 = reinterpret_cast< wxGrid * >(argp1);
11628 {
11629 PyThreadState* __tstate = wxPyBeginAllowThreads();
11630 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11631 wxPyEndAllowThreads(__tstate);
11632 if (PyErr_Occurred()) SWIG_fail;
11633 }
11634 {
11635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11636 }
11637 return resultobj;
11638 fail:
11639 return NULL;
11640 }
11641
11642
11643 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11644 PyObject *resultobj = 0;
11645 wxGrid *arg1 = (wxGrid *) 0 ;
11646 bool result;
11647 void *argp1 = 0 ;
11648 int res1 = 0 ;
11649 PyObject *swig_obj[1] ;
11650
11651 if (!args) SWIG_fail;
11652 swig_obj[0] = args;
11653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11656 }
11657 arg1 = reinterpret_cast< wxGrid * >(argp1);
11658 {
11659 PyThreadState* __tstate = wxPyBeginAllowThreads();
11660 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 {
11665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11666 }
11667 return resultobj;
11668 fail:
11669 return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11674 PyObject *resultobj = 0;
11675 wxGrid *arg1 = (wxGrid *) 0 ;
11676 bool result;
11677 void *argp1 = 0 ;
11678 int res1 = 0 ;
11679 PyObject *swig_obj[1] ;
11680
11681 if (!args) SWIG_fail;
11682 swig_obj[0] = args;
11683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11684 if (!SWIG_IsOK(res1)) {
11685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11686 }
11687 arg1 = reinterpret_cast< wxGrid * >(argp1);
11688 {
11689 PyThreadState* __tstate = wxPyBeginAllowThreads();
11690 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 {
11695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11696 }
11697 return resultobj;
11698 fail:
11699 return NULL;
11700 }
11701
11702
11703 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11704 PyObject *resultobj = 0;
11705 wxGrid *arg1 = (wxGrid *) 0 ;
11706 bool result;
11707 void *argp1 = 0 ;
11708 int res1 = 0 ;
11709 PyObject *swig_obj[1] ;
11710
11711 if (!args) SWIG_fail;
11712 swig_obj[0] = args;
11713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11714 if (!SWIG_IsOK(res1)) {
11715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11716 }
11717 arg1 = reinterpret_cast< wxGrid * >(argp1);
11718 {
11719 PyThreadState* __tstate = wxPyBeginAllowThreads();
11720 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 {
11725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11726 }
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11734 PyObject *resultobj = 0;
11735 wxGrid *arg1 = (wxGrid *) 0 ;
11736 void *argp1 = 0 ;
11737 int res1 = 0 ;
11738 PyObject *swig_obj[1] ;
11739
11740 if (!args) SWIG_fail;
11741 swig_obj[0] = args;
11742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11743 if (!SWIG_IsOK(res1)) {
11744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11745 }
11746 arg1 = reinterpret_cast< wxGrid * >(argp1);
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 (arg1)->ShowCellEditControl();
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 resultobj = SWIG_Py_Void();
11754 return resultobj;
11755 fail:
11756 return NULL;
11757 }
11758
11759
11760 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11761 PyObject *resultobj = 0;
11762 wxGrid *arg1 = (wxGrid *) 0 ;
11763 void *argp1 = 0 ;
11764 int res1 = 0 ;
11765 PyObject *swig_obj[1] ;
11766
11767 if (!args) SWIG_fail;
11768 swig_obj[0] = args;
11769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11770 if (!SWIG_IsOK(res1)) {
11771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11772 }
11773 arg1 = reinterpret_cast< wxGrid * >(argp1);
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 (arg1)->HideCellEditControl();
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_Py_Void();
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11788 PyObject *resultobj = 0;
11789 wxGrid *arg1 = (wxGrid *) 0 ;
11790 void *argp1 = 0 ;
11791 int res1 = 0 ;
11792 PyObject *swig_obj[1] ;
11793
11794 if (!args) SWIG_fail;
11795 swig_obj[0] = args;
11796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11797 if (!SWIG_IsOK(res1)) {
11798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11799 }
11800 arg1 = reinterpret_cast< wxGrid * >(argp1);
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 (arg1)->SaveEditControlValue();
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 resultobj = SWIG_Py_Void();
11808 return resultobj;
11809 fail:
11810 return NULL;
11811 }
11812
11813
11814 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11815 PyObject *resultobj = 0;
11816 wxGrid *arg1 = (wxGrid *) 0 ;
11817 int arg2 ;
11818 int arg3 ;
11819 wxGridCellCoords result;
11820 void *argp1 = 0 ;
11821 int res1 = 0 ;
11822 int val2 ;
11823 int ecode2 = 0 ;
11824 int val3 ;
11825 int ecode3 = 0 ;
11826 PyObject * obj0 = 0 ;
11827 PyObject * obj1 = 0 ;
11828 PyObject * obj2 = 0 ;
11829 char * kwnames[] = {
11830 (char *) "self",(char *) "x",(char *) "y", NULL
11831 };
11832
11833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11835 if (!SWIG_IsOK(res1)) {
11836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11837 }
11838 arg1 = reinterpret_cast< wxGrid * >(argp1);
11839 ecode2 = SWIG_AsVal_int(obj1, &val2);
11840 if (!SWIG_IsOK(ecode2)) {
11841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11842 }
11843 arg2 = static_cast< int >(val2);
11844 ecode3 = SWIG_AsVal_int(obj2, &val3);
11845 if (!SWIG_IsOK(ecode3)) {
11846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11847 }
11848 arg3 = static_cast< int >(val3);
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = wxGrid_XYToCell(arg1,arg2,arg3);
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11856 return resultobj;
11857 fail:
11858 return NULL;
11859 }
11860
11861
11862 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11863 PyObject *resultobj = 0;
11864 wxGrid *arg1 = (wxGrid *) 0 ;
11865 int arg2 ;
11866 int result;
11867 void *argp1 = 0 ;
11868 int res1 = 0 ;
11869 int val2 ;
11870 int ecode2 = 0 ;
11871 PyObject * obj0 = 0 ;
11872 PyObject * obj1 = 0 ;
11873 char * kwnames[] = {
11874 (char *) "self",(char *) "y", NULL
11875 };
11876
11877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11879 if (!SWIG_IsOK(res1)) {
11880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11881 }
11882 arg1 = reinterpret_cast< wxGrid * >(argp1);
11883 ecode2 = SWIG_AsVal_int(obj1, &val2);
11884 if (!SWIG_IsOK(ecode2)) {
11885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11886 }
11887 arg2 = static_cast< int >(val2);
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (int)(arg1)->YToRow(arg2);
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 resultobj = SWIG_From_int(static_cast< int >(result));
11895 return resultobj;
11896 fail:
11897 return NULL;
11898 }
11899
11900
11901 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11902 PyObject *resultobj = 0;
11903 wxGrid *arg1 = (wxGrid *) 0 ;
11904 int arg2 ;
11905 bool arg3 = (bool) false ;
11906 int result;
11907 void *argp1 = 0 ;
11908 int res1 = 0 ;
11909 int val2 ;
11910 int ecode2 = 0 ;
11911 bool val3 ;
11912 int ecode3 = 0 ;
11913 PyObject * obj0 = 0 ;
11914 PyObject * obj1 = 0 ;
11915 PyObject * obj2 = 0 ;
11916 char * kwnames[] = {
11917 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
11918 };
11919
11920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11922 if (!SWIG_IsOK(res1)) {
11923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11924 }
11925 arg1 = reinterpret_cast< wxGrid * >(argp1);
11926 ecode2 = SWIG_AsVal_int(obj1, &val2);
11927 if (!SWIG_IsOK(ecode2)) {
11928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11929 }
11930 arg2 = static_cast< int >(val2);
11931 if (obj2) {
11932 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11933 if (!SWIG_IsOK(ecode3)) {
11934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
11935 }
11936 arg3 = static_cast< bool >(val3);
11937 }
11938 {
11939 PyThreadState* __tstate = wxPyBeginAllowThreads();
11940 result = (int)(arg1)->XToCol(arg2,arg3);
11941 wxPyEndAllowThreads(__tstate);
11942 if (PyErr_Occurred()) SWIG_fail;
11943 }
11944 resultobj = SWIG_From_int(static_cast< int >(result));
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj = 0;
11953 wxGrid *arg1 = (wxGrid *) 0 ;
11954 int arg2 ;
11955 int result;
11956 void *argp1 = 0 ;
11957 int res1 = 0 ;
11958 int val2 ;
11959 int ecode2 = 0 ;
11960 PyObject * obj0 = 0 ;
11961 PyObject * obj1 = 0 ;
11962 char * kwnames[] = {
11963 (char *) "self",(char *) "y", NULL
11964 };
11965
11966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11968 if (!SWIG_IsOK(res1)) {
11969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11970 }
11971 arg1 = reinterpret_cast< wxGrid * >(argp1);
11972 ecode2 = SWIG_AsVal_int(obj1, &val2);
11973 if (!SWIG_IsOK(ecode2)) {
11974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11975 }
11976 arg2 = static_cast< int >(val2);
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = (int)(arg1)->YToEdgeOfRow(arg2);
11980 wxPyEndAllowThreads(__tstate);
11981 if (PyErr_Occurred()) SWIG_fail;
11982 }
11983 resultobj = SWIG_From_int(static_cast< int >(result));
11984 return resultobj;
11985 fail:
11986 return NULL;
11987 }
11988
11989
11990 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11991 PyObject *resultobj = 0;
11992 wxGrid *arg1 = (wxGrid *) 0 ;
11993 int arg2 ;
11994 int result;
11995 void *argp1 = 0 ;
11996 int res1 = 0 ;
11997 int val2 ;
11998 int ecode2 = 0 ;
11999 PyObject * obj0 = 0 ;
12000 PyObject * obj1 = 0 ;
12001 char * kwnames[] = {
12002 (char *) "self",(char *) "x", NULL
12003 };
12004
12005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12007 if (!SWIG_IsOK(res1)) {
12008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12009 }
12010 arg1 = reinterpret_cast< wxGrid * >(argp1);
12011 ecode2 = SWIG_AsVal_int(obj1, &val2);
12012 if (!SWIG_IsOK(ecode2)) {
12013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12014 }
12015 arg2 = static_cast< int >(val2);
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (int)(arg1)->XToEdgeOfCol(arg2);
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 resultobj = SWIG_From_int(static_cast< int >(result));
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12030 PyObject *resultobj = 0;
12031 wxGrid *arg1 = (wxGrid *) 0 ;
12032 int arg2 ;
12033 int arg3 ;
12034 wxRect result;
12035 void *argp1 = 0 ;
12036 int res1 = 0 ;
12037 int val2 ;
12038 int ecode2 = 0 ;
12039 int val3 ;
12040 int ecode3 = 0 ;
12041 PyObject * obj0 = 0 ;
12042 PyObject * obj1 = 0 ;
12043 PyObject * obj2 = 0 ;
12044 char * kwnames[] = {
12045 (char *) "self",(char *) "row",(char *) "col", NULL
12046 };
12047
12048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12050 if (!SWIG_IsOK(res1)) {
12051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12052 }
12053 arg1 = reinterpret_cast< wxGrid * >(argp1);
12054 ecode2 = SWIG_AsVal_int(obj1, &val2);
12055 if (!SWIG_IsOK(ecode2)) {
12056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12057 }
12058 arg2 = static_cast< int >(val2);
12059 ecode3 = SWIG_AsVal_int(obj2, &val3);
12060 if (!SWIG_IsOK(ecode3)) {
12061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12062 }
12063 arg3 = static_cast< int >(val3);
12064 {
12065 PyThreadState* __tstate = wxPyBeginAllowThreads();
12066 result = (arg1)->CellToRect(arg2,arg3);
12067 wxPyEndAllowThreads(__tstate);
12068 if (PyErr_Occurred()) SWIG_fail;
12069 }
12070 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12078 PyObject *resultobj = 0;
12079 wxGrid *arg1 = (wxGrid *) 0 ;
12080 int result;
12081 void *argp1 = 0 ;
12082 int res1 = 0 ;
12083 PyObject *swig_obj[1] ;
12084
12085 if (!args) SWIG_fail;
12086 swig_obj[0] = args;
12087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12088 if (!SWIG_IsOK(res1)) {
12089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12090 }
12091 arg1 = reinterpret_cast< wxGrid * >(argp1);
12092 {
12093 PyThreadState* __tstate = wxPyBeginAllowThreads();
12094 result = (int)(arg1)->GetGridCursorRow();
12095 wxPyEndAllowThreads(__tstate);
12096 if (PyErr_Occurred()) SWIG_fail;
12097 }
12098 resultobj = SWIG_From_int(static_cast< int >(result));
12099 return resultobj;
12100 fail:
12101 return NULL;
12102 }
12103
12104
12105 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12106 PyObject *resultobj = 0;
12107 wxGrid *arg1 = (wxGrid *) 0 ;
12108 int result;
12109 void *argp1 = 0 ;
12110 int res1 = 0 ;
12111 PyObject *swig_obj[1] ;
12112
12113 if (!args) SWIG_fail;
12114 swig_obj[0] = args;
12115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12116 if (!SWIG_IsOK(res1)) {
12117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12118 }
12119 arg1 = reinterpret_cast< wxGrid * >(argp1);
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 result = (int)(arg1)->GetGridCursorCol();
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 resultobj = SWIG_From_int(static_cast< int >(result));
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj = 0;
12135 wxGrid *arg1 = (wxGrid *) 0 ;
12136 int arg2 ;
12137 int arg3 ;
12138 bool arg4 = (bool) true ;
12139 bool result;
12140 void *argp1 = 0 ;
12141 int res1 = 0 ;
12142 int val2 ;
12143 int ecode2 = 0 ;
12144 int val3 ;
12145 int ecode3 = 0 ;
12146 bool val4 ;
12147 int ecode4 = 0 ;
12148 PyObject * obj0 = 0 ;
12149 PyObject * obj1 = 0 ;
12150 PyObject * obj2 = 0 ;
12151 PyObject * obj3 = 0 ;
12152 char * kwnames[] = {
12153 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12154 };
12155
12156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12158 if (!SWIG_IsOK(res1)) {
12159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12160 }
12161 arg1 = reinterpret_cast< wxGrid * >(argp1);
12162 ecode2 = SWIG_AsVal_int(obj1, &val2);
12163 if (!SWIG_IsOK(ecode2)) {
12164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12165 }
12166 arg2 = static_cast< int >(val2);
12167 ecode3 = SWIG_AsVal_int(obj2, &val3);
12168 if (!SWIG_IsOK(ecode3)) {
12169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12170 }
12171 arg3 = static_cast< int >(val3);
12172 if (obj3) {
12173 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12174 if (!SWIG_IsOK(ecode4)) {
12175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12176 }
12177 arg4 = static_cast< bool >(val4);
12178 }
12179 {
12180 PyThreadState* __tstate = wxPyBeginAllowThreads();
12181 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 {
12186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12187 }
12188 return resultobj;
12189 fail:
12190 return NULL;
12191 }
12192
12193
12194 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12195 PyObject *resultobj = 0;
12196 wxGrid *arg1 = (wxGrid *) 0 ;
12197 int arg2 ;
12198 int arg3 ;
12199 void *argp1 = 0 ;
12200 int res1 = 0 ;
12201 int val2 ;
12202 int ecode2 = 0 ;
12203 int val3 ;
12204 int ecode3 = 0 ;
12205 PyObject * obj0 = 0 ;
12206 PyObject * obj1 = 0 ;
12207 PyObject * obj2 = 0 ;
12208 char * kwnames[] = {
12209 (char *) "self",(char *) "row",(char *) "col", NULL
12210 };
12211
12212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12214 if (!SWIG_IsOK(res1)) {
12215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12216 }
12217 arg1 = reinterpret_cast< wxGrid * >(argp1);
12218 ecode2 = SWIG_AsVal_int(obj1, &val2);
12219 if (!SWIG_IsOK(ecode2)) {
12220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12221 }
12222 arg2 = static_cast< int >(val2);
12223 ecode3 = SWIG_AsVal_int(obj2, &val3);
12224 if (!SWIG_IsOK(ecode3)) {
12225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12226 }
12227 arg3 = static_cast< int >(val3);
12228 {
12229 PyThreadState* __tstate = wxPyBeginAllowThreads();
12230 (arg1)->MakeCellVisible(arg2,arg3);
12231 wxPyEndAllowThreads(__tstate);
12232 if (PyErr_Occurred()) SWIG_fail;
12233 }
12234 resultobj = SWIG_Py_Void();
12235 return resultobj;
12236 fail:
12237 return NULL;
12238 }
12239
12240
12241 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj = 0;
12243 wxGrid *arg1 = (wxGrid *) 0 ;
12244 int arg2 ;
12245 int arg3 ;
12246 void *argp1 = 0 ;
12247 int res1 = 0 ;
12248 int val2 ;
12249 int ecode2 = 0 ;
12250 int val3 ;
12251 int ecode3 = 0 ;
12252 PyObject * obj0 = 0 ;
12253 PyObject * obj1 = 0 ;
12254 PyObject * obj2 = 0 ;
12255 char * kwnames[] = {
12256 (char *) "self",(char *) "row",(char *) "col", NULL
12257 };
12258
12259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12261 if (!SWIG_IsOK(res1)) {
12262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12263 }
12264 arg1 = reinterpret_cast< wxGrid * >(argp1);
12265 ecode2 = SWIG_AsVal_int(obj1, &val2);
12266 if (!SWIG_IsOK(ecode2)) {
12267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12268 }
12269 arg2 = static_cast< int >(val2);
12270 ecode3 = SWIG_AsVal_int(obj2, &val3);
12271 if (!SWIG_IsOK(ecode3)) {
12272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12273 }
12274 arg3 = static_cast< int >(val3);
12275 {
12276 PyThreadState* __tstate = wxPyBeginAllowThreads();
12277 (arg1)->SetGridCursor(arg2,arg3);
12278 wxPyEndAllowThreads(__tstate);
12279 if (PyErr_Occurred()) SWIG_fail;
12280 }
12281 resultobj = SWIG_Py_Void();
12282 return resultobj;
12283 fail:
12284 return NULL;
12285 }
12286
12287
12288 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12289 PyObject *resultobj = 0;
12290 wxGrid *arg1 = (wxGrid *) 0 ;
12291 bool arg2 ;
12292 bool result;
12293 void *argp1 = 0 ;
12294 int res1 = 0 ;
12295 bool val2 ;
12296 int ecode2 = 0 ;
12297 PyObject * obj0 = 0 ;
12298 PyObject * obj1 = 0 ;
12299 char * kwnames[] = {
12300 (char *) "self",(char *) "expandSelection", NULL
12301 };
12302
12303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12305 if (!SWIG_IsOK(res1)) {
12306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12307 }
12308 arg1 = reinterpret_cast< wxGrid * >(argp1);
12309 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12310 if (!SWIG_IsOK(ecode2)) {
12311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12312 }
12313 arg2 = static_cast< bool >(val2);
12314 {
12315 PyThreadState* __tstate = wxPyBeginAllowThreads();
12316 result = (bool)(arg1)->MoveCursorUp(arg2);
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 {
12321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12322 }
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj = 0;
12331 wxGrid *arg1 = (wxGrid *) 0 ;
12332 bool arg2 ;
12333 bool result;
12334 void *argp1 = 0 ;
12335 int res1 = 0 ;
12336 bool val2 ;
12337 int ecode2 = 0 ;
12338 PyObject * obj0 = 0 ;
12339 PyObject * obj1 = 0 ;
12340 char * kwnames[] = {
12341 (char *) "self",(char *) "expandSelection", NULL
12342 };
12343
12344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12346 if (!SWIG_IsOK(res1)) {
12347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12348 }
12349 arg1 = reinterpret_cast< wxGrid * >(argp1);
12350 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12351 if (!SWIG_IsOK(ecode2)) {
12352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12353 }
12354 arg2 = static_cast< bool >(val2);
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 result = (bool)(arg1)->MoveCursorDown(arg2);
12358 wxPyEndAllowThreads(__tstate);
12359 if (PyErr_Occurred()) SWIG_fail;
12360 }
12361 {
12362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12363 }
12364 return resultobj;
12365 fail:
12366 return NULL;
12367 }
12368
12369
12370 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12371 PyObject *resultobj = 0;
12372 wxGrid *arg1 = (wxGrid *) 0 ;
12373 bool arg2 ;
12374 bool result;
12375 void *argp1 = 0 ;
12376 int res1 = 0 ;
12377 bool val2 ;
12378 int ecode2 = 0 ;
12379 PyObject * obj0 = 0 ;
12380 PyObject * obj1 = 0 ;
12381 char * kwnames[] = {
12382 (char *) "self",(char *) "expandSelection", NULL
12383 };
12384
12385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12387 if (!SWIG_IsOK(res1)) {
12388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12389 }
12390 arg1 = reinterpret_cast< wxGrid * >(argp1);
12391 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12392 if (!SWIG_IsOK(ecode2)) {
12393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12394 }
12395 arg2 = static_cast< bool >(val2);
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 result = (bool)(arg1)->MoveCursorLeft(arg2);
12399 wxPyEndAllowThreads(__tstate);
12400 if (PyErr_Occurred()) SWIG_fail;
12401 }
12402 {
12403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12404 }
12405 return resultobj;
12406 fail:
12407 return NULL;
12408 }
12409
12410
12411 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12412 PyObject *resultobj = 0;
12413 wxGrid *arg1 = (wxGrid *) 0 ;
12414 bool arg2 ;
12415 bool result;
12416 void *argp1 = 0 ;
12417 int res1 = 0 ;
12418 bool val2 ;
12419 int ecode2 = 0 ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 char * kwnames[] = {
12423 (char *) "self",(char *) "expandSelection", NULL
12424 };
12425
12426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12428 if (!SWIG_IsOK(res1)) {
12429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12430 }
12431 arg1 = reinterpret_cast< wxGrid * >(argp1);
12432 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12433 if (!SWIG_IsOK(ecode2)) {
12434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12435 }
12436 arg2 = static_cast< bool >(val2);
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 result = (bool)(arg1)->MoveCursorRight(arg2);
12440 wxPyEndAllowThreads(__tstate);
12441 if (PyErr_Occurred()) SWIG_fail;
12442 }
12443 {
12444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12445 }
12446 return resultobj;
12447 fail:
12448 return NULL;
12449 }
12450
12451
12452 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12453 PyObject *resultobj = 0;
12454 wxGrid *arg1 = (wxGrid *) 0 ;
12455 bool result;
12456 void *argp1 = 0 ;
12457 int res1 = 0 ;
12458 PyObject *swig_obj[1] ;
12459
12460 if (!args) SWIG_fail;
12461 swig_obj[0] = args;
12462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12463 if (!SWIG_IsOK(res1)) {
12464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12465 }
12466 arg1 = reinterpret_cast< wxGrid * >(argp1);
12467 {
12468 PyThreadState* __tstate = wxPyBeginAllowThreads();
12469 result = (bool)(arg1)->MovePageDown();
12470 wxPyEndAllowThreads(__tstate);
12471 if (PyErr_Occurred()) SWIG_fail;
12472 }
12473 {
12474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12475 }
12476 return resultobj;
12477 fail:
12478 return NULL;
12479 }
12480
12481
12482 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12483 PyObject *resultobj = 0;
12484 wxGrid *arg1 = (wxGrid *) 0 ;
12485 bool result;
12486 void *argp1 = 0 ;
12487 int res1 = 0 ;
12488 PyObject *swig_obj[1] ;
12489
12490 if (!args) SWIG_fail;
12491 swig_obj[0] = args;
12492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12493 if (!SWIG_IsOK(res1)) {
12494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12495 }
12496 arg1 = reinterpret_cast< wxGrid * >(argp1);
12497 {
12498 PyThreadState* __tstate = wxPyBeginAllowThreads();
12499 result = (bool)(arg1)->MovePageUp();
12500 wxPyEndAllowThreads(__tstate);
12501 if (PyErr_Occurred()) SWIG_fail;
12502 }
12503 {
12504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12505 }
12506 return resultobj;
12507 fail:
12508 return NULL;
12509 }
12510
12511
12512 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12513 PyObject *resultobj = 0;
12514 wxGrid *arg1 = (wxGrid *) 0 ;
12515 bool arg2 ;
12516 bool result;
12517 void *argp1 = 0 ;
12518 int res1 = 0 ;
12519 bool val2 ;
12520 int ecode2 = 0 ;
12521 PyObject * obj0 = 0 ;
12522 PyObject * obj1 = 0 ;
12523 char * kwnames[] = {
12524 (char *) "self",(char *) "expandSelection", NULL
12525 };
12526
12527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12529 if (!SWIG_IsOK(res1)) {
12530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12531 }
12532 arg1 = reinterpret_cast< wxGrid * >(argp1);
12533 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12534 if (!SWIG_IsOK(ecode2)) {
12535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12536 }
12537 arg2 = static_cast< bool >(val2);
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 {
12545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12546 }
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj = 0;
12555 wxGrid *arg1 = (wxGrid *) 0 ;
12556 bool arg2 ;
12557 bool result;
12558 void *argp1 = 0 ;
12559 int res1 = 0 ;
12560 bool val2 ;
12561 int ecode2 = 0 ;
12562 PyObject * obj0 = 0 ;
12563 PyObject * obj1 = 0 ;
12564 char * kwnames[] = {
12565 (char *) "self",(char *) "expandSelection", NULL
12566 };
12567
12568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12570 if (!SWIG_IsOK(res1)) {
12571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12572 }
12573 arg1 = reinterpret_cast< wxGrid * >(argp1);
12574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12575 if (!SWIG_IsOK(ecode2)) {
12576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12577 }
12578 arg2 = static_cast< bool >(val2);
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 {
12586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12587 }
12588 return resultobj;
12589 fail:
12590 return NULL;
12591 }
12592
12593
12594 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12595 PyObject *resultobj = 0;
12596 wxGrid *arg1 = (wxGrid *) 0 ;
12597 bool arg2 ;
12598 bool result;
12599 void *argp1 = 0 ;
12600 int res1 = 0 ;
12601 bool val2 ;
12602 int ecode2 = 0 ;
12603 PyObject * obj0 = 0 ;
12604 PyObject * obj1 = 0 ;
12605 char * kwnames[] = {
12606 (char *) "self",(char *) "expandSelection", NULL
12607 };
12608
12609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12611 if (!SWIG_IsOK(res1)) {
12612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12613 }
12614 arg1 = reinterpret_cast< wxGrid * >(argp1);
12615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12616 if (!SWIG_IsOK(ecode2)) {
12617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12618 }
12619 arg2 = static_cast< bool >(val2);
12620 {
12621 PyThreadState* __tstate = wxPyBeginAllowThreads();
12622 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12623 wxPyEndAllowThreads(__tstate);
12624 if (PyErr_Occurred()) SWIG_fail;
12625 }
12626 {
12627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12628 }
12629 return resultobj;
12630 fail:
12631 return NULL;
12632 }
12633
12634
12635 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12636 PyObject *resultobj = 0;
12637 wxGrid *arg1 = (wxGrid *) 0 ;
12638 bool arg2 ;
12639 bool result;
12640 void *argp1 = 0 ;
12641 int res1 = 0 ;
12642 bool val2 ;
12643 int ecode2 = 0 ;
12644 PyObject * obj0 = 0 ;
12645 PyObject * obj1 = 0 ;
12646 char * kwnames[] = {
12647 (char *) "self",(char *) "expandSelection", NULL
12648 };
12649
12650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12652 if (!SWIG_IsOK(res1)) {
12653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12654 }
12655 arg1 = reinterpret_cast< wxGrid * >(argp1);
12656 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12657 if (!SWIG_IsOK(ecode2)) {
12658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12659 }
12660 arg2 = static_cast< bool >(val2);
12661 {
12662 PyThreadState* __tstate = wxPyBeginAllowThreads();
12663 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 {
12668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12669 }
12670 return resultobj;
12671 fail:
12672 return NULL;
12673 }
12674
12675
12676 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12677 PyObject *resultobj = 0;
12678 wxGrid *arg1 = (wxGrid *) 0 ;
12679 int result;
12680 void *argp1 = 0 ;
12681 int res1 = 0 ;
12682 PyObject *swig_obj[1] ;
12683
12684 if (!args) SWIG_fail;
12685 swig_obj[0] = args;
12686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12687 if (!SWIG_IsOK(res1)) {
12688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12689 }
12690 arg1 = reinterpret_cast< wxGrid * >(argp1);
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 result = (int)(arg1)->GetDefaultRowLabelSize();
12694 wxPyEndAllowThreads(__tstate);
12695 if (PyErr_Occurred()) SWIG_fail;
12696 }
12697 resultobj = SWIG_From_int(static_cast< int >(result));
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12705 PyObject *resultobj = 0;
12706 wxGrid *arg1 = (wxGrid *) 0 ;
12707 int result;
12708 void *argp1 = 0 ;
12709 int res1 = 0 ;
12710 PyObject *swig_obj[1] ;
12711
12712 if (!args) SWIG_fail;
12713 swig_obj[0] = args;
12714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12715 if (!SWIG_IsOK(res1)) {
12716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12717 }
12718 arg1 = reinterpret_cast< wxGrid * >(argp1);
12719 {
12720 PyThreadState* __tstate = wxPyBeginAllowThreads();
12721 result = (int)(arg1)->GetRowLabelSize();
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 resultobj = SWIG_From_int(static_cast< int >(result));
12726 return resultobj;
12727 fail:
12728 return NULL;
12729 }
12730
12731
12732 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12733 PyObject *resultobj = 0;
12734 wxGrid *arg1 = (wxGrid *) 0 ;
12735 int result;
12736 void *argp1 = 0 ;
12737 int res1 = 0 ;
12738 PyObject *swig_obj[1] ;
12739
12740 if (!args) SWIG_fail;
12741 swig_obj[0] = args;
12742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12743 if (!SWIG_IsOK(res1)) {
12744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12745 }
12746 arg1 = reinterpret_cast< wxGrid * >(argp1);
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 result = (int)(arg1)->GetDefaultColLabelSize();
12750 wxPyEndAllowThreads(__tstate);
12751 if (PyErr_Occurred()) SWIG_fail;
12752 }
12753 resultobj = SWIG_From_int(static_cast< int >(result));
12754 return resultobj;
12755 fail:
12756 return NULL;
12757 }
12758
12759
12760 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12761 PyObject *resultobj = 0;
12762 wxGrid *arg1 = (wxGrid *) 0 ;
12763 int result;
12764 void *argp1 = 0 ;
12765 int res1 = 0 ;
12766 PyObject *swig_obj[1] ;
12767
12768 if (!args) SWIG_fail;
12769 swig_obj[0] = args;
12770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12771 if (!SWIG_IsOK(res1)) {
12772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12773 }
12774 arg1 = reinterpret_cast< wxGrid * >(argp1);
12775 {
12776 PyThreadState* __tstate = wxPyBeginAllowThreads();
12777 result = (int)(arg1)->GetColLabelSize();
12778 wxPyEndAllowThreads(__tstate);
12779 if (PyErr_Occurred()) SWIG_fail;
12780 }
12781 resultobj = SWIG_From_int(static_cast< int >(result));
12782 return resultobj;
12783 fail:
12784 return NULL;
12785 }
12786
12787
12788 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12789 PyObject *resultobj = 0;
12790 wxGrid *arg1 = (wxGrid *) 0 ;
12791 wxColour result;
12792 void *argp1 = 0 ;
12793 int res1 = 0 ;
12794 PyObject *swig_obj[1] ;
12795
12796 if (!args) SWIG_fail;
12797 swig_obj[0] = args;
12798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12799 if (!SWIG_IsOK(res1)) {
12800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12801 }
12802 arg1 = reinterpret_cast< wxGrid * >(argp1);
12803 {
12804 PyThreadState* __tstate = wxPyBeginAllowThreads();
12805 result = (arg1)->GetLabelBackgroundColour();
12806 wxPyEndAllowThreads(__tstate);
12807 if (PyErr_Occurred()) SWIG_fail;
12808 }
12809 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12810 return resultobj;
12811 fail:
12812 return NULL;
12813 }
12814
12815
12816 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12817 PyObject *resultobj = 0;
12818 wxGrid *arg1 = (wxGrid *) 0 ;
12819 wxColour result;
12820 void *argp1 = 0 ;
12821 int res1 = 0 ;
12822 PyObject *swig_obj[1] ;
12823
12824 if (!args) SWIG_fail;
12825 swig_obj[0] = args;
12826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12827 if (!SWIG_IsOK(res1)) {
12828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12829 }
12830 arg1 = reinterpret_cast< wxGrid * >(argp1);
12831 {
12832 PyThreadState* __tstate = wxPyBeginAllowThreads();
12833 result = (arg1)->GetLabelTextColour();
12834 wxPyEndAllowThreads(__tstate);
12835 if (PyErr_Occurred()) SWIG_fail;
12836 }
12837 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12845 PyObject *resultobj = 0;
12846 wxGrid *arg1 = (wxGrid *) 0 ;
12847 wxFont result;
12848 void *argp1 = 0 ;
12849 int res1 = 0 ;
12850 PyObject *swig_obj[1] ;
12851
12852 if (!args) SWIG_fail;
12853 swig_obj[0] = args;
12854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12855 if (!SWIG_IsOK(res1)) {
12856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12857 }
12858 arg1 = reinterpret_cast< wxGrid * >(argp1);
12859 {
12860 PyThreadState* __tstate = wxPyBeginAllowThreads();
12861 result = (arg1)->GetLabelFont();
12862 wxPyEndAllowThreads(__tstate);
12863 if (PyErr_Occurred()) SWIG_fail;
12864 }
12865 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12866 return resultobj;
12867 fail:
12868 return NULL;
12869 }
12870
12871
12872 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12873 PyObject *resultobj = 0;
12874 wxGrid *arg1 = (wxGrid *) 0 ;
12875 int *arg2 = (int *) 0 ;
12876 int *arg3 = (int *) 0 ;
12877 void *argp1 = 0 ;
12878 int res1 = 0 ;
12879 int temp2 ;
12880 int res2 = SWIG_TMPOBJ ;
12881 int temp3 ;
12882 int res3 = SWIG_TMPOBJ ;
12883 PyObject *swig_obj[1] ;
12884
12885 arg2 = &temp2;
12886 arg3 = &temp3;
12887 if (!args) SWIG_fail;
12888 swig_obj[0] = args;
12889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12890 if (!SWIG_IsOK(res1)) {
12891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12892 }
12893 arg1 = reinterpret_cast< wxGrid * >(argp1);
12894 {
12895 PyThreadState* __tstate = wxPyBeginAllowThreads();
12896 (arg1)->GetRowLabelAlignment(arg2,arg3);
12897 wxPyEndAllowThreads(__tstate);
12898 if (PyErr_Occurred()) SWIG_fail;
12899 }
12900 resultobj = SWIG_Py_Void();
12901 if (SWIG_IsTmpObj(res2)) {
12902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12903 } else {
12904 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12906 }
12907 if (SWIG_IsTmpObj(res3)) {
12908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12909 } else {
12910 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12912 }
12913 return resultobj;
12914 fail:
12915 return NULL;
12916 }
12917
12918
12919 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12920 PyObject *resultobj = 0;
12921 wxGrid *arg1 = (wxGrid *) 0 ;
12922 int *arg2 = (int *) 0 ;
12923 int *arg3 = (int *) 0 ;
12924 void *argp1 = 0 ;
12925 int res1 = 0 ;
12926 int temp2 ;
12927 int res2 = SWIG_TMPOBJ ;
12928 int temp3 ;
12929 int res3 = SWIG_TMPOBJ ;
12930 PyObject *swig_obj[1] ;
12931
12932 arg2 = &temp2;
12933 arg3 = &temp3;
12934 if (!args) SWIG_fail;
12935 swig_obj[0] = args;
12936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12937 if (!SWIG_IsOK(res1)) {
12938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12939 }
12940 arg1 = reinterpret_cast< wxGrid * >(argp1);
12941 {
12942 PyThreadState* __tstate = wxPyBeginAllowThreads();
12943 (arg1)->GetColLabelAlignment(arg2,arg3);
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 resultobj = SWIG_Py_Void();
12948 if (SWIG_IsTmpObj(res2)) {
12949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12950 } else {
12951 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12953 }
12954 if (SWIG_IsTmpObj(res3)) {
12955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12956 } else {
12957 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12959 }
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 PyObject *resultobj = 0;
12968 wxGrid *arg1 = (wxGrid *) 0 ;
12969 int result;
12970 void *argp1 = 0 ;
12971 int res1 = 0 ;
12972 PyObject *swig_obj[1] ;
12973
12974 if (!args) SWIG_fail;
12975 swig_obj[0] = args;
12976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12977 if (!SWIG_IsOK(res1)) {
12978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12979 }
12980 arg1 = reinterpret_cast< wxGrid * >(argp1);
12981 {
12982 PyThreadState* __tstate = wxPyBeginAllowThreads();
12983 result = (int)(arg1)->GetColLabelTextOrientation();
12984 wxPyEndAllowThreads(__tstate);
12985 if (PyErr_Occurred()) SWIG_fail;
12986 }
12987 resultobj = SWIG_From_int(static_cast< int >(result));
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj = 0;
12996 wxGrid *arg1 = (wxGrid *) 0 ;
12997 int arg2 ;
12998 wxString result;
12999 void *argp1 = 0 ;
13000 int res1 = 0 ;
13001 int val2 ;
13002 int ecode2 = 0 ;
13003 PyObject * obj0 = 0 ;
13004 PyObject * obj1 = 0 ;
13005 char * kwnames[] = {
13006 (char *) "self",(char *) "row", NULL
13007 };
13008
13009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13011 if (!SWIG_IsOK(res1)) {
13012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13013 }
13014 arg1 = reinterpret_cast< wxGrid * >(argp1);
13015 ecode2 = SWIG_AsVal_int(obj1, &val2);
13016 if (!SWIG_IsOK(ecode2)) {
13017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13018 }
13019 arg2 = static_cast< int >(val2);
13020 {
13021 PyThreadState* __tstate = wxPyBeginAllowThreads();
13022 result = (arg1)->GetRowLabelValue(arg2);
13023 wxPyEndAllowThreads(__tstate);
13024 if (PyErr_Occurred()) SWIG_fail;
13025 }
13026 {
13027 #if wxUSE_UNICODE
13028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13029 #else
13030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13031 #endif
13032 }
13033 return resultobj;
13034 fail:
13035 return NULL;
13036 }
13037
13038
13039 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13040 PyObject *resultobj = 0;
13041 wxGrid *arg1 = (wxGrid *) 0 ;
13042 int arg2 ;
13043 wxString result;
13044 void *argp1 = 0 ;
13045 int res1 = 0 ;
13046 int val2 ;
13047 int ecode2 = 0 ;
13048 PyObject * obj0 = 0 ;
13049 PyObject * obj1 = 0 ;
13050 char * kwnames[] = {
13051 (char *) "self",(char *) "col", NULL
13052 };
13053
13054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13056 if (!SWIG_IsOK(res1)) {
13057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13058 }
13059 arg1 = reinterpret_cast< wxGrid * >(argp1);
13060 ecode2 = SWIG_AsVal_int(obj1, &val2);
13061 if (!SWIG_IsOK(ecode2)) {
13062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13063 }
13064 arg2 = static_cast< int >(val2);
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = (arg1)->GetColLabelValue(arg2);
13068 wxPyEndAllowThreads(__tstate);
13069 if (PyErr_Occurred()) SWIG_fail;
13070 }
13071 {
13072 #if wxUSE_UNICODE
13073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13074 #else
13075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13076 #endif
13077 }
13078 return resultobj;
13079 fail:
13080 return NULL;
13081 }
13082
13083
13084 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 PyObject *resultobj = 0;
13086 wxGrid *arg1 = (wxGrid *) 0 ;
13087 wxColour result;
13088 void *argp1 = 0 ;
13089 int res1 = 0 ;
13090 PyObject *swig_obj[1] ;
13091
13092 if (!args) SWIG_fail;
13093 swig_obj[0] = args;
13094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13095 if (!SWIG_IsOK(res1)) {
13096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13097 }
13098 arg1 = reinterpret_cast< wxGrid * >(argp1);
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 result = (arg1)->GetGridLineColour();
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13106 return resultobj;
13107 fail:
13108 return NULL;
13109 }
13110
13111
13112 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13113 PyObject *resultobj = 0;
13114 wxGrid *arg1 = (wxGrid *) 0 ;
13115 wxColour result;
13116 void *argp1 = 0 ;
13117 int res1 = 0 ;
13118 PyObject *swig_obj[1] ;
13119
13120 if (!args) SWIG_fail;
13121 swig_obj[0] = args;
13122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13123 if (!SWIG_IsOK(res1)) {
13124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13125 }
13126 arg1 = reinterpret_cast< wxGrid * >(argp1);
13127 {
13128 PyThreadState* __tstate = wxPyBeginAllowThreads();
13129 result = (arg1)->GetCellHighlightColour();
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13134 return resultobj;
13135 fail:
13136 return NULL;
13137 }
13138
13139
13140 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13141 PyObject *resultobj = 0;
13142 wxGrid *arg1 = (wxGrid *) 0 ;
13143 int result;
13144 void *argp1 = 0 ;
13145 int res1 = 0 ;
13146 PyObject *swig_obj[1] ;
13147
13148 if (!args) SWIG_fail;
13149 swig_obj[0] = args;
13150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13151 if (!SWIG_IsOK(res1)) {
13152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13153 }
13154 arg1 = reinterpret_cast< wxGrid * >(argp1);
13155 {
13156 PyThreadState* __tstate = wxPyBeginAllowThreads();
13157 result = (int)(arg1)->GetCellHighlightPenWidth();
13158 wxPyEndAllowThreads(__tstate);
13159 if (PyErr_Occurred()) SWIG_fail;
13160 }
13161 resultobj = SWIG_From_int(static_cast< int >(result));
13162 return resultobj;
13163 fail:
13164 return NULL;
13165 }
13166
13167
13168 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13169 PyObject *resultobj = 0;
13170 wxGrid *arg1 = (wxGrid *) 0 ;
13171 int result;
13172 void *argp1 = 0 ;
13173 int res1 = 0 ;
13174 PyObject *swig_obj[1] ;
13175
13176 if (!args) SWIG_fail;
13177 swig_obj[0] = args;
13178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13179 if (!SWIG_IsOK(res1)) {
13180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13181 }
13182 arg1 = reinterpret_cast< wxGrid * >(argp1);
13183 {
13184 PyThreadState* __tstate = wxPyBeginAllowThreads();
13185 result = (int)(arg1)->GetCellHighlightROPenWidth();
13186 wxPyEndAllowThreads(__tstate);
13187 if (PyErr_Occurred()) SWIG_fail;
13188 }
13189 resultobj = SWIG_From_int(static_cast< int >(result));
13190 return resultobj;
13191 fail:
13192 return NULL;
13193 }
13194
13195
13196 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13197 PyObject *resultobj = 0;
13198 wxGrid *arg1 = (wxGrid *) 0 ;
13199 int arg2 ;
13200 void *argp1 = 0 ;
13201 int res1 = 0 ;
13202 int val2 ;
13203 int ecode2 = 0 ;
13204 PyObject * obj0 = 0 ;
13205 PyObject * obj1 = 0 ;
13206 char * kwnames[] = {
13207 (char *) "self",(char *) "width", NULL
13208 };
13209
13210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13212 if (!SWIG_IsOK(res1)) {
13213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13214 }
13215 arg1 = reinterpret_cast< wxGrid * >(argp1);
13216 ecode2 = SWIG_AsVal_int(obj1, &val2);
13217 if (!SWIG_IsOK(ecode2)) {
13218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13219 }
13220 arg2 = static_cast< int >(val2);
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 (arg1)->SetRowLabelSize(arg2);
13224 wxPyEndAllowThreads(__tstate);
13225 if (PyErr_Occurred()) SWIG_fail;
13226 }
13227 resultobj = SWIG_Py_Void();
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13235 PyObject *resultobj = 0;
13236 wxGrid *arg1 = (wxGrid *) 0 ;
13237 int arg2 ;
13238 void *argp1 = 0 ;
13239 int res1 = 0 ;
13240 int val2 ;
13241 int ecode2 = 0 ;
13242 PyObject * obj0 = 0 ;
13243 PyObject * obj1 = 0 ;
13244 char * kwnames[] = {
13245 (char *) "self",(char *) "height", NULL
13246 };
13247
13248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13250 if (!SWIG_IsOK(res1)) {
13251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13252 }
13253 arg1 = reinterpret_cast< wxGrid * >(argp1);
13254 ecode2 = SWIG_AsVal_int(obj1, &val2);
13255 if (!SWIG_IsOK(ecode2)) {
13256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13257 }
13258 arg2 = static_cast< int >(val2);
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 (arg1)->SetColLabelSize(arg2);
13262 wxPyEndAllowThreads(__tstate);
13263 if (PyErr_Occurred()) SWIG_fail;
13264 }
13265 resultobj = SWIG_Py_Void();
13266 return resultobj;
13267 fail:
13268 return NULL;
13269 }
13270
13271
13272 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13273 PyObject *resultobj = 0;
13274 wxGrid *arg1 = (wxGrid *) 0 ;
13275 wxColour *arg2 = 0 ;
13276 void *argp1 = 0 ;
13277 int res1 = 0 ;
13278 wxColour temp2 ;
13279 PyObject * obj0 = 0 ;
13280 PyObject * obj1 = 0 ;
13281 char * kwnames[] = {
13282 (char *) "self",(char *)"arg2", NULL
13283 };
13284
13285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13287 if (!SWIG_IsOK(res1)) {
13288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13289 }
13290 arg1 = reinterpret_cast< wxGrid * >(argp1);
13291 {
13292 arg2 = &temp2;
13293 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13294 }
13295 {
13296 PyThreadState* __tstate = wxPyBeginAllowThreads();
13297 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13298 wxPyEndAllowThreads(__tstate);
13299 if (PyErr_Occurred()) SWIG_fail;
13300 }
13301 resultobj = SWIG_Py_Void();
13302 return resultobj;
13303 fail:
13304 return NULL;
13305 }
13306
13307
13308 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13309 PyObject *resultobj = 0;
13310 wxGrid *arg1 = (wxGrid *) 0 ;
13311 wxColour *arg2 = 0 ;
13312 void *argp1 = 0 ;
13313 int res1 = 0 ;
13314 wxColour temp2 ;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 char * kwnames[] = {
13318 (char *) "self",(char *)"arg2", NULL
13319 };
13320
13321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13325 }
13326 arg1 = reinterpret_cast< wxGrid * >(argp1);
13327 {
13328 arg2 = &temp2;
13329 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13330 }
13331 {
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 resultobj = SWIG_Py_Void();
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13345 PyObject *resultobj = 0;
13346 wxGrid *arg1 = (wxGrid *) 0 ;
13347 wxFont *arg2 = 0 ;
13348 void *argp1 = 0 ;
13349 int res1 = 0 ;
13350 void *argp2 = 0 ;
13351 int res2 = 0 ;
13352 PyObject * obj0 = 0 ;
13353 PyObject * obj1 = 0 ;
13354 char * kwnames[] = {
13355 (char *) "self",(char *)"arg2", NULL
13356 };
13357
13358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13360 if (!SWIG_IsOK(res1)) {
13361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13362 }
13363 arg1 = reinterpret_cast< wxGrid * >(argp1);
13364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13365 if (!SWIG_IsOK(res2)) {
13366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13367 }
13368 if (!argp2) {
13369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13370 }
13371 arg2 = reinterpret_cast< wxFont * >(argp2);
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 (arg1)->SetLabelFont((wxFont const &)*arg2);
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 resultobj = SWIG_Py_Void();
13379 return resultobj;
13380 fail:
13381 return NULL;
13382 }
13383
13384
13385 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13386 PyObject *resultobj = 0;
13387 wxGrid *arg1 = (wxGrid *) 0 ;
13388 int arg2 ;
13389 int arg3 ;
13390 void *argp1 = 0 ;
13391 int res1 = 0 ;
13392 int val2 ;
13393 int ecode2 = 0 ;
13394 int val3 ;
13395 int ecode3 = 0 ;
13396 PyObject * obj0 = 0 ;
13397 PyObject * obj1 = 0 ;
13398 PyObject * obj2 = 0 ;
13399 char * kwnames[] = {
13400 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13401 };
13402
13403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13405 if (!SWIG_IsOK(res1)) {
13406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13407 }
13408 arg1 = reinterpret_cast< wxGrid * >(argp1);
13409 ecode2 = SWIG_AsVal_int(obj1, &val2);
13410 if (!SWIG_IsOK(ecode2)) {
13411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13412 }
13413 arg2 = static_cast< int >(val2);
13414 ecode3 = SWIG_AsVal_int(obj2, &val3);
13415 if (!SWIG_IsOK(ecode3)) {
13416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13417 }
13418 arg3 = static_cast< int >(val3);
13419 {
13420 PyThreadState* __tstate = wxPyBeginAllowThreads();
13421 (arg1)->SetRowLabelAlignment(arg2,arg3);
13422 wxPyEndAllowThreads(__tstate);
13423 if (PyErr_Occurred()) SWIG_fail;
13424 }
13425 resultobj = SWIG_Py_Void();
13426 return resultobj;
13427 fail:
13428 return NULL;
13429 }
13430
13431
13432 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13433 PyObject *resultobj = 0;
13434 wxGrid *arg1 = (wxGrid *) 0 ;
13435 int arg2 ;
13436 int arg3 ;
13437 void *argp1 = 0 ;
13438 int res1 = 0 ;
13439 int val2 ;
13440 int ecode2 = 0 ;
13441 int val3 ;
13442 int ecode3 = 0 ;
13443 PyObject * obj0 = 0 ;
13444 PyObject * obj1 = 0 ;
13445 PyObject * obj2 = 0 ;
13446 char * kwnames[] = {
13447 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13448 };
13449
13450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13452 if (!SWIG_IsOK(res1)) {
13453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13454 }
13455 arg1 = reinterpret_cast< wxGrid * >(argp1);
13456 ecode2 = SWIG_AsVal_int(obj1, &val2);
13457 if (!SWIG_IsOK(ecode2)) {
13458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13459 }
13460 arg2 = static_cast< int >(val2);
13461 ecode3 = SWIG_AsVal_int(obj2, &val3);
13462 if (!SWIG_IsOK(ecode3)) {
13463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13464 }
13465 arg3 = static_cast< int >(val3);
13466 {
13467 PyThreadState* __tstate = wxPyBeginAllowThreads();
13468 (arg1)->SetColLabelAlignment(arg2,arg3);
13469 wxPyEndAllowThreads(__tstate);
13470 if (PyErr_Occurred()) SWIG_fail;
13471 }
13472 resultobj = SWIG_Py_Void();
13473 return resultobj;
13474 fail:
13475 return NULL;
13476 }
13477
13478
13479 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13480 PyObject *resultobj = 0;
13481 wxGrid *arg1 = (wxGrid *) 0 ;
13482 int arg2 ;
13483 void *argp1 = 0 ;
13484 int res1 = 0 ;
13485 int val2 ;
13486 int ecode2 = 0 ;
13487 PyObject * obj0 = 0 ;
13488 PyObject * obj1 = 0 ;
13489 char * kwnames[] = {
13490 (char *) "self",(char *) "textOrientation", NULL
13491 };
13492
13493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13495 if (!SWIG_IsOK(res1)) {
13496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13497 }
13498 arg1 = reinterpret_cast< wxGrid * >(argp1);
13499 ecode2 = SWIG_AsVal_int(obj1, &val2);
13500 if (!SWIG_IsOK(ecode2)) {
13501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13502 }
13503 arg2 = static_cast< int >(val2);
13504 {
13505 PyThreadState* __tstate = wxPyBeginAllowThreads();
13506 (arg1)->SetColLabelTextOrientation(arg2);
13507 wxPyEndAllowThreads(__tstate);
13508 if (PyErr_Occurred()) SWIG_fail;
13509 }
13510 resultobj = SWIG_Py_Void();
13511 return resultobj;
13512 fail:
13513 return NULL;
13514 }
13515
13516
13517 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13518 PyObject *resultobj = 0;
13519 wxGrid *arg1 = (wxGrid *) 0 ;
13520 int arg2 ;
13521 wxString *arg3 = 0 ;
13522 void *argp1 = 0 ;
13523 int res1 = 0 ;
13524 int val2 ;
13525 int ecode2 = 0 ;
13526 bool temp3 = false ;
13527 PyObject * obj0 = 0 ;
13528 PyObject * obj1 = 0 ;
13529 PyObject * obj2 = 0 ;
13530 char * kwnames[] = {
13531 (char *) "self",(char *) "row",(char *)"arg3", NULL
13532 };
13533
13534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13536 if (!SWIG_IsOK(res1)) {
13537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13538 }
13539 arg1 = reinterpret_cast< wxGrid * >(argp1);
13540 ecode2 = SWIG_AsVal_int(obj1, &val2);
13541 if (!SWIG_IsOK(ecode2)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13543 }
13544 arg2 = static_cast< int >(val2);
13545 {
13546 arg3 = wxString_in_helper(obj2);
13547 if (arg3 == NULL) SWIG_fail;
13548 temp3 = true;
13549 }
13550 {
13551 PyThreadState* __tstate = wxPyBeginAllowThreads();
13552 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 resultobj = SWIG_Py_Void();
13557 {
13558 if (temp3)
13559 delete arg3;
13560 }
13561 return resultobj;
13562 fail:
13563 {
13564 if (temp3)
13565 delete arg3;
13566 }
13567 return NULL;
13568 }
13569
13570
13571 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj = 0;
13573 wxGrid *arg1 = (wxGrid *) 0 ;
13574 int arg2 ;
13575 wxString *arg3 = 0 ;
13576 void *argp1 = 0 ;
13577 int res1 = 0 ;
13578 int val2 ;
13579 int ecode2 = 0 ;
13580 bool temp3 = false ;
13581 PyObject * obj0 = 0 ;
13582 PyObject * obj1 = 0 ;
13583 PyObject * obj2 = 0 ;
13584 char * kwnames[] = {
13585 (char *) "self",(char *) "col",(char *)"arg3", NULL
13586 };
13587
13588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13590 if (!SWIG_IsOK(res1)) {
13591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13592 }
13593 arg1 = reinterpret_cast< wxGrid * >(argp1);
13594 ecode2 = SWIG_AsVal_int(obj1, &val2);
13595 if (!SWIG_IsOK(ecode2)) {
13596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13597 }
13598 arg2 = static_cast< int >(val2);
13599 {
13600 arg3 = wxString_in_helper(obj2);
13601 if (arg3 == NULL) SWIG_fail;
13602 temp3 = true;
13603 }
13604 {
13605 PyThreadState* __tstate = wxPyBeginAllowThreads();
13606 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 resultobj = SWIG_Py_Void();
13611 {
13612 if (temp3)
13613 delete arg3;
13614 }
13615 return resultobj;
13616 fail:
13617 {
13618 if (temp3)
13619 delete arg3;
13620 }
13621 return NULL;
13622 }
13623
13624
13625 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj = 0;
13627 wxGrid *arg1 = (wxGrid *) 0 ;
13628 wxColour *arg2 = 0 ;
13629 void *argp1 = 0 ;
13630 int res1 = 0 ;
13631 wxColour temp2 ;
13632 PyObject * obj0 = 0 ;
13633 PyObject * obj1 = 0 ;
13634 char * kwnames[] = {
13635 (char *) "self",(char *)"arg2", NULL
13636 };
13637
13638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13640 if (!SWIG_IsOK(res1)) {
13641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13642 }
13643 arg1 = reinterpret_cast< wxGrid * >(argp1);
13644 {
13645 arg2 = &temp2;
13646 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13647 }
13648 {
13649 PyThreadState* __tstate = wxPyBeginAllowThreads();
13650 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13651 wxPyEndAllowThreads(__tstate);
13652 if (PyErr_Occurred()) SWIG_fail;
13653 }
13654 resultobj = SWIG_Py_Void();
13655 return resultobj;
13656 fail:
13657 return NULL;
13658 }
13659
13660
13661 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13662 PyObject *resultobj = 0;
13663 wxGrid *arg1 = (wxGrid *) 0 ;
13664 wxColour *arg2 = 0 ;
13665 void *argp1 = 0 ;
13666 int res1 = 0 ;
13667 wxColour temp2 ;
13668 PyObject * obj0 = 0 ;
13669 PyObject * obj1 = 0 ;
13670 char * kwnames[] = {
13671 (char *) "self",(char *)"arg2", NULL
13672 };
13673
13674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13676 if (!SWIG_IsOK(res1)) {
13677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13678 }
13679 arg1 = reinterpret_cast< wxGrid * >(argp1);
13680 {
13681 arg2 = &temp2;
13682 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13683 }
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 resultobj = SWIG_Py_Void();
13691 return resultobj;
13692 fail:
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxGrid *arg1 = (wxGrid *) 0 ;
13700 int arg2 ;
13701 void *argp1 = 0 ;
13702 int res1 = 0 ;
13703 int val2 ;
13704 int ecode2 = 0 ;
13705 PyObject * obj0 = 0 ;
13706 PyObject * obj1 = 0 ;
13707 char * kwnames[] = {
13708 (char *) "self",(char *) "width", NULL
13709 };
13710
13711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13713 if (!SWIG_IsOK(res1)) {
13714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13715 }
13716 arg1 = reinterpret_cast< wxGrid * >(argp1);
13717 ecode2 = SWIG_AsVal_int(obj1, &val2);
13718 if (!SWIG_IsOK(ecode2)) {
13719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13720 }
13721 arg2 = static_cast< int >(val2);
13722 {
13723 PyThreadState* __tstate = wxPyBeginAllowThreads();
13724 (arg1)->SetCellHighlightPenWidth(arg2);
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 resultobj = SWIG_Py_Void();
13729 return resultobj;
13730 fail:
13731 return NULL;
13732 }
13733
13734
13735 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13736 PyObject *resultobj = 0;
13737 wxGrid *arg1 = (wxGrid *) 0 ;
13738 int arg2 ;
13739 void *argp1 = 0 ;
13740 int res1 = 0 ;
13741 int val2 ;
13742 int ecode2 = 0 ;
13743 PyObject * obj0 = 0 ;
13744 PyObject * obj1 = 0 ;
13745 char * kwnames[] = {
13746 (char *) "self",(char *) "width", NULL
13747 };
13748
13749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13751 if (!SWIG_IsOK(res1)) {
13752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13753 }
13754 arg1 = reinterpret_cast< wxGrid * >(argp1);
13755 ecode2 = SWIG_AsVal_int(obj1, &val2);
13756 if (!SWIG_IsOK(ecode2)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13758 }
13759 arg2 = static_cast< int >(val2);
13760 {
13761 PyThreadState* __tstate = wxPyBeginAllowThreads();
13762 (arg1)->SetCellHighlightROPenWidth(arg2);
13763 wxPyEndAllowThreads(__tstate);
13764 if (PyErr_Occurred()) SWIG_fail;
13765 }
13766 resultobj = SWIG_Py_Void();
13767 return resultobj;
13768 fail:
13769 return NULL;
13770 }
13771
13772
13773 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13774 PyObject *resultobj = 0;
13775 wxGrid *arg1 = (wxGrid *) 0 ;
13776 bool arg2 = (bool) true ;
13777 void *argp1 = 0 ;
13778 int res1 = 0 ;
13779 bool val2 ;
13780 int ecode2 = 0 ;
13781 PyObject * obj0 = 0 ;
13782 PyObject * obj1 = 0 ;
13783 char * kwnames[] = {
13784 (char *) "self",(char *) "enable", NULL
13785 };
13786
13787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13789 if (!SWIG_IsOK(res1)) {
13790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13791 }
13792 arg1 = reinterpret_cast< wxGrid * >(argp1);
13793 if (obj1) {
13794 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13795 if (!SWIG_IsOK(ecode2)) {
13796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13797 }
13798 arg2 = static_cast< bool >(val2);
13799 }
13800 {
13801 PyThreadState* __tstate = wxPyBeginAllowThreads();
13802 (arg1)->EnableDragRowSize(arg2);
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 resultobj = SWIG_Py_Void();
13807 return resultobj;
13808 fail:
13809 return NULL;
13810 }
13811
13812
13813 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13814 PyObject *resultobj = 0;
13815 wxGrid *arg1 = (wxGrid *) 0 ;
13816 void *argp1 = 0 ;
13817 int res1 = 0 ;
13818 PyObject *swig_obj[1] ;
13819
13820 if (!args) SWIG_fail;
13821 swig_obj[0] = args;
13822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13823 if (!SWIG_IsOK(res1)) {
13824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13825 }
13826 arg1 = reinterpret_cast< wxGrid * >(argp1);
13827 {
13828 PyThreadState* __tstate = wxPyBeginAllowThreads();
13829 (arg1)->DisableDragRowSize();
13830 wxPyEndAllowThreads(__tstate);
13831 if (PyErr_Occurred()) SWIG_fail;
13832 }
13833 resultobj = SWIG_Py_Void();
13834 return resultobj;
13835 fail:
13836 return NULL;
13837 }
13838
13839
13840 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13841 PyObject *resultobj = 0;
13842 wxGrid *arg1 = (wxGrid *) 0 ;
13843 bool result;
13844 void *argp1 = 0 ;
13845 int res1 = 0 ;
13846 PyObject *swig_obj[1] ;
13847
13848 if (!args) SWIG_fail;
13849 swig_obj[0] = args;
13850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13851 if (!SWIG_IsOK(res1)) {
13852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13853 }
13854 arg1 = reinterpret_cast< wxGrid * >(argp1);
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 result = (bool)(arg1)->CanDragRowSize();
13858 wxPyEndAllowThreads(__tstate);
13859 if (PyErr_Occurred()) SWIG_fail;
13860 }
13861 {
13862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13863 }
13864 return resultobj;
13865 fail:
13866 return NULL;
13867 }
13868
13869
13870 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13871 PyObject *resultobj = 0;
13872 wxGrid *arg1 = (wxGrid *) 0 ;
13873 bool arg2 = (bool) true ;
13874 void *argp1 = 0 ;
13875 int res1 = 0 ;
13876 bool val2 ;
13877 int ecode2 = 0 ;
13878 PyObject * obj0 = 0 ;
13879 PyObject * obj1 = 0 ;
13880 char * kwnames[] = {
13881 (char *) "self",(char *) "enable", NULL
13882 };
13883
13884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13886 if (!SWIG_IsOK(res1)) {
13887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13888 }
13889 arg1 = reinterpret_cast< wxGrid * >(argp1);
13890 if (obj1) {
13891 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13892 if (!SWIG_IsOK(ecode2)) {
13893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
13894 }
13895 arg2 = static_cast< bool >(val2);
13896 }
13897 {
13898 PyThreadState* __tstate = wxPyBeginAllowThreads();
13899 (arg1)->EnableDragColSize(arg2);
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 resultobj = SWIG_Py_Void();
13904 return resultobj;
13905 fail:
13906 return NULL;
13907 }
13908
13909
13910 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13911 PyObject *resultobj = 0;
13912 wxGrid *arg1 = (wxGrid *) 0 ;
13913 void *argp1 = 0 ;
13914 int res1 = 0 ;
13915 PyObject *swig_obj[1] ;
13916
13917 if (!args) SWIG_fail;
13918 swig_obj[0] = args;
13919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13920 if (!SWIG_IsOK(res1)) {
13921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13922 }
13923 arg1 = reinterpret_cast< wxGrid * >(argp1);
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 (arg1)->DisableDragColSize();
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_Py_Void();
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13938 PyObject *resultobj = 0;
13939 wxGrid *arg1 = (wxGrid *) 0 ;
13940 bool result;
13941 void *argp1 = 0 ;
13942 int res1 = 0 ;
13943 PyObject *swig_obj[1] ;
13944
13945 if (!args) SWIG_fail;
13946 swig_obj[0] = args;
13947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13948 if (!SWIG_IsOK(res1)) {
13949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13950 }
13951 arg1 = reinterpret_cast< wxGrid * >(argp1);
13952 {
13953 PyThreadState* __tstate = wxPyBeginAllowThreads();
13954 result = (bool)(arg1)->CanDragColSize();
13955 wxPyEndAllowThreads(__tstate);
13956 if (PyErr_Occurred()) SWIG_fail;
13957 }
13958 {
13959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13960 }
13961 return resultobj;
13962 fail:
13963 return NULL;
13964 }
13965
13966
13967 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13968 PyObject *resultobj = 0;
13969 wxGrid *arg1 = (wxGrid *) 0 ;
13970 bool arg2 = (bool) true ;
13971 void *argp1 = 0 ;
13972 int res1 = 0 ;
13973 bool val2 ;
13974 int ecode2 = 0 ;
13975 PyObject * obj0 = 0 ;
13976 PyObject * obj1 = 0 ;
13977 char * kwnames[] = {
13978 (char *) "self",(char *) "enable", NULL
13979 };
13980
13981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
13982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13983 if (!SWIG_IsOK(res1)) {
13984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
13985 }
13986 arg1 = reinterpret_cast< wxGrid * >(argp1);
13987 if (obj1) {
13988 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13989 if (!SWIG_IsOK(ecode2)) {
13990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
13991 }
13992 arg2 = static_cast< bool >(val2);
13993 }
13994 {
13995 PyThreadState* __tstate = wxPyBeginAllowThreads();
13996 (arg1)->EnableDragColMove(arg2);
13997 wxPyEndAllowThreads(__tstate);
13998 if (PyErr_Occurred()) SWIG_fail;
13999 }
14000 resultobj = SWIG_Py_Void();
14001 return resultobj;
14002 fail:
14003 return NULL;
14004 }
14005
14006
14007 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14008 PyObject *resultobj = 0;
14009 wxGrid *arg1 = (wxGrid *) 0 ;
14010 void *argp1 = 0 ;
14011 int res1 = 0 ;
14012 PyObject *swig_obj[1] ;
14013
14014 if (!args) SWIG_fail;
14015 swig_obj[0] = args;
14016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14017 if (!SWIG_IsOK(res1)) {
14018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14019 }
14020 arg1 = reinterpret_cast< wxGrid * >(argp1);
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 (arg1)->DisableDragColMove();
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_Py_Void();
14028 return resultobj;
14029 fail:
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14035 PyObject *resultobj = 0;
14036 wxGrid *arg1 = (wxGrid *) 0 ;
14037 bool result;
14038 void *argp1 = 0 ;
14039 int res1 = 0 ;
14040 PyObject *swig_obj[1] ;
14041
14042 if (!args) SWIG_fail;
14043 swig_obj[0] = args;
14044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14045 if (!SWIG_IsOK(res1)) {
14046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14047 }
14048 arg1 = reinterpret_cast< wxGrid * >(argp1);
14049 {
14050 PyThreadState* __tstate = wxPyBeginAllowThreads();
14051 result = (bool)(arg1)->CanDragColMove();
14052 wxPyEndAllowThreads(__tstate);
14053 if (PyErr_Occurred()) SWIG_fail;
14054 }
14055 {
14056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14057 }
14058 return resultobj;
14059 fail:
14060 return NULL;
14061 }
14062
14063
14064 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14065 PyObject *resultobj = 0;
14066 wxGrid *arg1 = (wxGrid *) 0 ;
14067 bool arg2 = (bool) true ;
14068 void *argp1 = 0 ;
14069 int res1 = 0 ;
14070 bool val2 ;
14071 int ecode2 = 0 ;
14072 PyObject * obj0 = 0 ;
14073 PyObject * obj1 = 0 ;
14074 char * kwnames[] = {
14075 (char *) "self",(char *) "enable", NULL
14076 };
14077
14078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14080 if (!SWIG_IsOK(res1)) {
14081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14082 }
14083 arg1 = reinterpret_cast< wxGrid * >(argp1);
14084 if (obj1) {
14085 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14086 if (!SWIG_IsOK(ecode2)) {
14087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14088 }
14089 arg2 = static_cast< bool >(val2);
14090 }
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 (arg1)->EnableDragGridSize(arg2);
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 resultobj = SWIG_Py_Void();
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14105 PyObject *resultobj = 0;
14106 wxGrid *arg1 = (wxGrid *) 0 ;
14107 void *argp1 = 0 ;
14108 int res1 = 0 ;
14109 PyObject *swig_obj[1] ;
14110
14111 if (!args) SWIG_fail;
14112 swig_obj[0] = args;
14113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14114 if (!SWIG_IsOK(res1)) {
14115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14116 }
14117 arg1 = reinterpret_cast< wxGrid * >(argp1);
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 (arg1)->DisableDragGridSize();
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 resultobj = SWIG_Py_Void();
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14132 PyObject *resultobj = 0;
14133 wxGrid *arg1 = (wxGrid *) 0 ;
14134 bool result;
14135 void *argp1 = 0 ;
14136 int res1 = 0 ;
14137 PyObject *swig_obj[1] ;
14138
14139 if (!args) SWIG_fail;
14140 swig_obj[0] = args;
14141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14142 if (!SWIG_IsOK(res1)) {
14143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14144 }
14145 arg1 = reinterpret_cast< wxGrid * >(argp1);
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 result = (bool)(arg1)->CanDragGridSize();
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 {
14153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14154 }
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj = 0;
14163 wxGrid *arg1 = (wxGrid *) 0 ;
14164 bool arg2 = (bool) true ;
14165 void *argp1 = 0 ;
14166 int res1 = 0 ;
14167 bool val2 ;
14168 int ecode2 = 0 ;
14169 PyObject * obj0 = 0 ;
14170 PyObject * obj1 = 0 ;
14171 char * kwnames[] = {
14172 (char *) "self",(char *) "enable", NULL
14173 };
14174
14175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14177 if (!SWIG_IsOK(res1)) {
14178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14179 }
14180 arg1 = reinterpret_cast< wxGrid * >(argp1);
14181 if (obj1) {
14182 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14183 if (!SWIG_IsOK(ecode2)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14185 }
14186 arg2 = static_cast< bool >(val2);
14187 }
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 (arg1)->EnableDragCell(arg2);
14191 wxPyEndAllowThreads(__tstate);
14192 if (PyErr_Occurred()) SWIG_fail;
14193 }
14194 resultobj = SWIG_Py_Void();
14195 return resultobj;
14196 fail:
14197 return NULL;
14198 }
14199
14200
14201 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14202 PyObject *resultobj = 0;
14203 wxGrid *arg1 = (wxGrid *) 0 ;
14204 void *argp1 = 0 ;
14205 int res1 = 0 ;
14206 PyObject *swig_obj[1] ;
14207
14208 if (!args) SWIG_fail;
14209 swig_obj[0] = args;
14210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14211 if (!SWIG_IsOK(res1)) {
14212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14213 }
14214 arg1 = reinterpret_cast< wxGrid * >(argp1);
14215 {
14216 PyThreadState* __tstate = wxPyBeginAllowThreads();
14217 (arg1)->DisableDragCell();
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 resultobj = SWIG_Py_Void();
14222 return resultobj;
14223 fail:
14224 return NULL;
14225 }
14226
14227
14228 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14229 PyObject *resultobj = 0;
14230 wxGrid *arg1 = (wxGrid *) 0 ;
14231 bool result;
14232 void *argp1 = 0 ;
14233 int res1 = 0 ;
14234 PyObject *swig_obj[1] ;
14235
14236 if (!args) SWIG_fail;
14237 swig_obj[0] = args;
14238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14239 if (!SWIG_IsOK(res1)) {
14240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14241 }
14242 arg1 = reinterpret_cast< wxGrid * >(argp1);
14243 {
14244 PyThreadState* __tstate = wxPyBeginAllowThreads();
14245 result = (bool)(arg1)->CanDragCell();
14246 wxPyEndAllowThreads(__tstate);
14247 if (PyErr_Occurred()) SWIG_fail;
14248 }
14249 {
14250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14251 }
14252 return resultobj;
14253 fail:
14254 return NULL;
14255 }
14256
14257
14258 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14259 PyObject *resultobj = 0;
14260 wxGrid *arg1 = (wxGrid *) 0 ;
14261 int arg2 ;
14262 int arg3 ;
14263 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14264 void *argp1 = 0 ;
14265 int res1 = 0 ;
14266 int val2 ;
14267 int ecode2 = 0 ;
14268 int val3 ;
14269 int ecode3 = 0 ;
14270 void *argp4 = 0 ;
14271 int res4 = 0 ;
14272 PyObject * obj0 = 0 ;
14273 PyObject * obj1 = 0 ;
14274 PyObject * obj2 = 0 ;
14275 PyObject * obj3 = 0 ;
14276 char * kwnames[] = {
14277 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14278 };
14279
14280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14282 if (!SWIG_IsOK(res1)) {
14283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14284 }
14285 arg1 = reinterpret_cast< wxGrid * >(argp1);
14286 ecode2 = SWIG_AsVal_int(obj1, &val2);
14287 if (!SWIG_IsOK(ecode2)) {
14288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14289 }
14290 arg2 = static_cast< int >(val2);
14291 ecode3 = SWIG_AsVal_int(obj2, &val3);
14292 if (!SWIG_IsOK(ecode3)) {
14293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14294 }
14295 arg3 = static_cast< int >(val3);
14296 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14297 if (!SWIG_IsOK(res4)) {
14298 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14299 }
14300 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 (arg1)->SetAttr(arg2,arg3,arg4);
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 resultobj = SWIG_Py_Void();
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14315 PyObject *resultobj = 0;
14316 wxGrid *arg1 = (wxGrid *) 0 ;
14317 int arg2 ;
14318 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14319 void *argp1 = 0 ;
14320 int res1 = 0 ;
14321 int val2 ;
14322 int ecode2 = 0 ;
14323 void *argp3 = 0 ;
14324 int res3 = 0 ;
14325 PyObject * obj0 = 0 ;
14326 PyObject * obj1 = 0 ;
14327 PyObject * obj2 = 0 ;
14328 char * kwnames[] = {
14329 (char *) "self",(char *) "row",(char *) "attr", NULL
14330 };
14331
14332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14334 if (!SWIG_IsOK(res1)) {
14335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14336 }
14337 arg1 = reinterpret_cast< wxGrid * >(argp1);
14338 ecode2 = SWIG_AsVal_int(obj1, &val2);
14339 if (!SWIG_IsOK(ecode2)) {
14340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14341 }
14342 arg2 = static_cast< int >(val2);
14343 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14344 if (!SWIG_IsOK(res3)) {
14345 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14346 }
14347 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14348 {
14349 PyThreadState* __tstate = wxPyBeginAllowThreads();
14350 (arg1)->SetRowAttr(arg2,arg3);
14351 wxPyEndAllowThreads(__tstate);
14352 if (PyErr_Occurred()) SWIG_fail;
14353 }
14354 resultobj = SWIG_Py_Void();
14355 return resultobj;
14356 fail:
14357 return NULL;
14358 }
14359
14360
14361 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14362 PyObject *resultobj = 0;
14363 wxGrid *arg1 = (wxGrid *) 0 ;
14364 int arg2 ;
14365 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14366 void *argp1 = 0 ;
14367 int res1 = 0 ;
14368 int val2 ;
14369 int ecode2 = 0 ;
14370 void *argp3 = 0 ;
14371 int res3 = 0 ;
14372 PyObject * obj0 = 0 ;
14373 PyObject * obj1 = 0 ;
14374 PyObject * obj2 = 0 ;
14375 char * kwnames[] = {
14376 (char *) "self",(char *) "col",(char *) "attr", NULL
14377 };
14378
14379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14381 if (!SWIG_IsOK(res1)) {
14382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14383 }
14384 arg1 = reinterpret_cast< wxGrid * >(argp1);
14385 ecode2 = SWIG_AsVal_int(obj1, &val2);
14386 if (!SWIG_IsOK(ecode2)) {
14387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14388 }
14389 arg2 = static_cast< int >(val2);
14390 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14391 if (!SWIG_IsOK(res3)) {
14392 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14393 }
14394 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 (arg1)->SetColAttr(arg2,arg3);
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 resultobj = SWIG_Py_Void();
14402 return resultobj;
14403 fail:
14404 return NULL;
14405 }
14406
14407
14408 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj = 0;
14410 wxGrid *arg1 = (wxGrid *) 0 ;
14411 int arg2 ;
14412 int arg3 ;
14413 wxGridCellAttr *result = 0 ;
14414 void *argp1 = 0 ;
14415 int res1 = 0 ;
14416 int val2 ;
14417 int ecode2 = 0 ;
14418 int val3 ;
14419 int ecode3 = 0 ;
14420 PyObject * obj0 = 0 ;
14421 PyObject * obj1 = 0 ;
14422 PyObject * obj2 = 0 ;
14423 char * kwnames[] = {
14424 (char *) "self",(char *) "row",(char *) "col", NULL
14425 };
14426
14427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14431 }
14432 arg1 = reinterpret_cast< wxGrid * >(argp1);
14433 ecode2 = SWIG_AsVal_int(obj1, &val2);
14434 if (!SWIG_IsOK(ecode2)) {
14435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14436 }
14437 arg2 = static_cast< int >(val2);
14438 ecode3 = SWIG_AsVal_int(obj2, &val3);
14439 if (!SWIG_IsOK(ecode3)) {
14440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14441 }
14442 arg3 = static_cast< int >(val3);
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14446 wxPyEndAllowThreads(__tstate);
14447 if (PyErr_Occurred()) SWIG_fail;
14448 }
14449 {
14450 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14451 }
14452 return resultobj;
14453 fail:
14454 return NULL;
14455 }
14456
14457
14458 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = 0;
14460 wxGrid *arg1 = (wxGrid *) 0 ;
14461 int arg2 ;
14462 void *argp1 = 0 ;
14463 int res1 = 0 ;
14464 int val2 ;
14465 int ecode2 = 0 ;
14466 PyObject * obj0 = 0 ;
14467 PyObject * obj1 = 0 ;
14468 char * kwnames[] = {
14469 (char *) "self",(char *) "col", NULL
14470 };
14471
14472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14474 if (!SWIG_IsOK(res1)) {
14475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14476 }
14477 arg1 = reinterpret_cast< wxGrid * >(argp1);
14478 ecode2 = SWIG_AsVal_int(obj1, &val2);
14479 if (!SWIG_IsOK(ecode2)) {
14480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14481 }
14482 arg2 = static_cast< int >(val2);
14483 {
14484 PyThreadState* __tstate = wxPyBeginAllowThreads();
14485 (arg1)->SetColFormatBool(arg2);
14486 wxPyEndAllowThreads(__tstate);
14487 if (PyErr_Occurred()) SWIG_fail;
14488 }
14489 resultobj = SWIG_Py_Void();
14490 return resultobj;
14491 fail:
14492 return NULL;
14493 }
14494
14495
14496 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14497 PyObject *resultobj = 0;
14498 wxGrid *arg1 = (wxGrid *) 0 ;
14499 int arg2 ;
14500 void *argp1 = 0 ;
14501 int res1 = 0 ;
14502 int val2 ;
14503 int ecode2 = 0 ;
14504 PyObject * obj0 = 0 ;
14505 PyObject * obj1 = 0 ;
14506 char * kwnames[] = {
14507 (char *) "self",(char *) "col", NULL
14508 };
14509
14510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14512 if (!SWIG_IsOK(res1)) {
14513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14514 }
14515 arg1 = reinterpret_cast< wxGrid * >(argp1);
14516 ecode2 = SWIG_AsVal_int(obj1, &val2);
14517 if (!SWIG_IsOK(ecode2)) {
14518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14519 }
14520 arg2 = static_cast< int >(val2);
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 (arg1)->SetColFormatNumber(arg2);
14524 wxPyEndAllowThreads(__tstate);
14525 if (PyErr_Occurred()) SWIG_fail;
14526 }
14527 resultobj = SWIG_Py_Void();
14528 return resultobj;
14529 fail:
14530 return NULL;
14531 }
14532
14533
14534 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14535 PyObject *resultobj = 0;
14536 wxGrid *arg1 = (wxGrid *) 0 ;
14537 int arg2 ;
14538 int arg3 = (int) -1 ;
14539 int arg4 = (int) -1 ;
14540 void *argp1 = 0 ;
14541 int res1 = 0 ;
14542 int val2 ;
14543 int ecode2 = 0 ;
14544 int val3 ;
14545 int ecode3 = 0 ;
14546 int val4 ;
14547 int ecode4 = 0 ;
14548 PyObject * obj0 = 0 ;
14549 PyObject * obj1 = 0 ;
14550 PyObject * obj2 = 0 ;
14551 PyObject * obj3 = 0 ;
14552 char * kwnames[] = {
14553 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14554 };
14555
14556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14558 if (!SWIG_IsOK(res1)) {
14559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14560 }
14561 arg1 = reinterpret_cast< wxGrid * >(argp1);
14562 ecode2 = SWIG_AsVal_int(obj1, &val2);
14563 if (!SWIG_IsOK(ecode2)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14565 }
14566 arg2 = static_cast< int >(val2);
14567 if (obj2) {
14568 ecode3 = SWIG_AsVal_int(obj2, &val3);
14569 if (!SWIG_IsOK(ecode3)) {
14570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14571 }
14572 arg3 = static_cast< int >(val3);
14573 }
14574 if (obj3) {
14575 ecode4 = SWIG_AsVal_int(obj3, &val4);
14576 if (!SWIG_IsOK(ecode4)) {
14577 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14578 }
14579 arg4 = static_cast< int >(val4);
14580 }
14581 {
14582 PyThreadState* __tstate = wxPyBeginAllowThreads();
14583 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14584 wxPyEndAllowThreads(__tstate);
14585 if (PyErr_Occurred()) SWIG_fail;
14586 }
14587 resultobj = SWIG_Py_Void();
14588 return resultobj;
14589 fail:
14590 return NULL;
14591 }
14592
14593
14594 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14595 PyObject *resultobj = 0;
14596 wxGrid *arg1 = (wxGrid *) 0 ;
14597 int arg2 ;
14598 wxString *arg3 = 0 ;
14599 void *argp1 = 0 ;
14600 int res1 = 0 ;
14601 int val2 ;
14602 int ecode2 = 0 ;
14603 bool temp3 = false ;
14604 PyObject * obj0 = 0 ;
14605 PyObject * obj1 = 0 ;
14606 PyObject * obj2 = 0 ;
14607 char * kwnames[] = {
14608 (char *) "self",(char *) "col",(char *) "typeName", NULL
14609 };
14610
14611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14613 if (!SWIG_IsOK(res1)) {
14614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14615 }
14616 arg1 = reinterpret_cast< wxGrid * >(argp1);
14617 ecode2 = SWIG_AsVal_int(obj1, &val2);
14618 if (!SWIG_IsOK(ecode2)) {
14619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14620 }
14621 arg2 = static_cast< int >(val2);
14622 {
14623 arg3 = wxString_in_helper(obj2);
14624 if (arg3 == NULL) SWIG_fail;
14625 temp3 = true;
14626 }
14627 {
14628 PyThreadState* __tstate = wxPyBeginAllowThreads();
14629 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 resultobj = SWIG_Py_Void();
14634 {
14635 if (temp3)
14636 delete arg3;
14637 }
14638 return resultobj;
14639 fail:
14640 {
14641 if (temp3)
14642 delete arg3;
14643 }
14644 return NULL;
14645 }
14646
14647
14648 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14649 PyObject *resultobj = 0;
14650 wxGrid *arg1 = (wxGrid *) 0 ;
14651 bool arg2 = (bool) true ;
14652 void *argp1 = 0 ;
14653 int res1 = 0 ;
14654 bool val2 ;
14655 int ecode2 = 0 ;
14656 PyObject * obj0 = 0 ;
14657 PyObject * obj1 = 0 ;
14658 char * kwnames[] = {
14659 (char *) "self",(char *) "enable", NULL
14660 };
14661
14662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14664 if (!SWIG_IsOK(res1)) {
14665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14666 }
14667 arg1 = reinterpret_cast< wxGrid * >(argp1);
14668 if (obj1) {
14669 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14670 if (!SWIG_IsOK(ecode2)) {
14671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14672 }
14673 arg2 = static_cast< bool >(val2);
14674 }
14675 {
14676 PyThreadState* __tstate = wxPyBeginAllowThreads();
14677 (arg1)->EnableGridLines(arg2);
14678 wxPyEndAllowThreads(__tstate);
14679 if (PyErr_Occurred()) SWIG_fail;
14680 }
14681 resultobj = SWIG_Py_Void();
14682 return resultobj;
14683 fail:
14684 return NULL;
14685 }
14686
14687
14688 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14689 PyObject *resultobj = 0;
14690 wxGrid *arg1 = (wxGrid *) 0 ;
14691 bool result;
14692 void *argp1 = 0 ;
14693 int res1 = 0 ;
14694 PyObject *swig_obj[1] ;
14695
14696 if (!args) SWIG_fail;
14697 swig_obj[0] = args;
14698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14699 if (!SWIG_IsOK(res1)) {
14700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14701 }
14702 arg1 = reinterpret_cast< wxGrid * >(argp1);
14703 {
14704 PyThreadState* __tstate = wxPyBeginAllowThreads();
14705 result = (bool)(arg1)->GridLinesEnabled();
14706 wxPyEndAllowThreads(__tstate);
14707 if (PyErr_Occurred()) SWIG_fail;
14708 }
14709 {
14710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14711 }
14712 return resultobj;
14713 fail:
14714 return NULL;
14715 }
14716
14717
14718 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14719 PyObject *resultobj = 0;
14720 wxGrid *arg1 = (wxGrid *) 0 ;
14721 int result;
14722 void *argp1 = 0 ;
14723 int res1 = 0 ;
14724 PyObject *swig_obj[1] ;
14725
14726 if (!args) SWIG_fail;
14727 swig_obj[0] = args;
14728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14729 if (!SWIG_IsOK(res1)) {
14730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14731 }
14732 arg1 = reinterpret_cast< wxGrid * >(argp1);
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 result = (int)(arg1)->GetDefaultRowSize();
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 resultobj = SWIG_From_int(static_cast< int >(result));
14740 return resultobj;
14741 fail:
14742 return NULL;
14743 }
14744
14745
14746 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14747 PyObject *resultobj = 0;
14748 wxGrid *arg1 = (wxGrid *) 0 ;
14749 int arg2 ;
14750 int result;
14751 void *argp1 = 0 ;
14752 int res1 = 0 ;
14753 int val2 ;
14754 int ecode2 = 0 ;
14755 PyObject * obj0 = 0 ;
14756 PyObject * obj1 = 0 ;
14757 char * kwnames[] = {
14758 (char *) "self",(char *) "row", NULL
14759 };
14760
14761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14763 if (!SWIG_IsOK(res1)) {
14764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14765 }
14766 arg1 = reinterpret_cast< wxGrid * >(argp1);
14767 ecode2 = SWIG_AsVal_int(obj1, &val2);
14768 if (!SWIG_IsOK(ecode2)) {
14769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14770 }
14771 arg2 = static_cast< int >(val2);
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 result = (int)(arg1)->GetRowSize(arg2);
14775 wxPyEndAllowThreads(__tstate);
14776 if (PyErr_Occurred()) SWIG_fail;
14777 }
14778 resultobj = SWIG_From_int(static_cast< int >(result));
14779 return resultobj;
14780 fail:
14781 return NULL;
14782 }
14783
14784
14785 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14786 PyObject *resultobj = 0;
14787 wxGrid *arg1 = (wxGrid *) 0 ;
14788 int result;
14789 void *argp1 = 0 ;
14790 int res1 = 0 ;
14791 PyObject *swig_obj[1] ;
14792
14793 if (!args) SWIG_fail;
14794 swig_obj[0] = args;
14795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14796 if (!SWIG_IsOK(res1)) {
14797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14798 }
14799 arg1 = reinterpret_cast< wxGrid * >(argp1);
14800 {
14801 PyThreadState* __tstate = wxPyBeginAllowThreads();
14802 result = (int)(arg1)->GetDefaultColSize();
14803 wxPyEndAllowThreads(__tstate);
14804 if (PyErr_Occurred()) SWIG_fail;
14805 }
14806 resultobj = SWIG_From_int(static_cast< int >(result));
14807 return resultobj;
14808 fail:
14809 return NULL;
14810 }
14811
14812
14813 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14814 PyObject *resultobj = 0;
14815 wxGrid *arg1 = (wxGrid *) 0 ;
14816 int arg2 ;
14817 int result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 int val2 ;
14821 int ecode2 = 0 ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 char * kwnames[] = {
14825 (char *) "self",(char *) "col", NULL
14826 };
14827
14828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14830 if (!SWIG_IsOK(res1)) {
14831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14832 }
14833 arg1 = reinterpret_cast< wxGrid * >(argp1);
14834 ecode2 = SWIG_AsVal_int(obj1, &val2);
14835 if (!SWIG_IsOK(ecode2)) {
14836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14837 }
14838 arg2 = static_cast< int >(val2);
14839 {
14840 PyThreadState* __tstate = wxPyBeginAllowThreads();
14841 result = (int)(arg1)->GetColSize(arg2);
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 resultobj = SWIG_From_int(static_cast< int >(result));
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14853 PyObject *resultobj = 0;
14854 wxGrid *arg1 = (wxGrid *) 0 ;
14855 wxColour result;
14856 void *argp1 = 0 ;
14857 int res1 = 0 ;
14858 PyObject *swig_obj[1] ;
14859
14860 if (!args) SWIG_fail;
14861 swig_obj[0] = args;
14862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14863 if (!SWIG_IsOK(res1)) {
14864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14865 }
14866 arg1 = reinterpret_cast< wxGrid * >(argp1);
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 result = (arg1)->GetDefaultCellBackgroundColour();
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14881 PyObject *resultobj = 0;
14882 wxGrid *arg1 = (wxGrid *) 0 ;
14883 int arg2 ;
14884 int arg3 ;
14885 wxColour result;
14886 void *argp1 = 0 ;
14887 int res1 = 0 ;
14888 int val2 ;
14889 int ecode2 = 0 ;
14890 int val3 ;
14891 int ecode3 = 0 ;
14892 PyObject * obj0 = 0 ;
14893 PyObject * obj1 = 0 ;
14894 PyObject * obj2 = 0 ;
14895 char * kwnames[] = {
14896 (char *) "self",(char *) "row",(char *) "col", NULL
14897 };
14898
14899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14901 if (!SWIG_IsOK(res1)) {
14902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14903 }
14904 arg1 = reinterpret_cast< wxGrid * >(argp1);
14905 ecode2 = SWIG_AsVal_int(obj1, &val2);
14906 if (!SWIG_IsOK(ecode2)) {
14907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
14908 }
14909 arg2 = static_cast< int >(val2);
14910 ecode3 = SWIG_AsVal_int(obj2, &val3);
14911 if (!SWIG_IsOK(ecode3)) {
14912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
14913 }
14914 arg3 = static_cast< int >(val3);
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14929 PyObject *resultobj = 0;
14930 wxGrid *arg1 = (wxGrid *) 0 ;
14931 wxColour result;
14932 void *argp1 = 0 ;
14933 int res1 = 0 ;
14934 PyObject *swig_obj[1] ;
14935
14936 if (!args) SWIG_fail;
14937 swig_obj[0] = args;
14938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14939 if (!SWIG_IsOK(res1)) {
14940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14941 }
14942 arg1 = reinterpret_cast< wxGrid * >(argp1);
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (arg1)->GetDefaultCellTextColour();
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj = 0;
14958 wxGrid *arg1 = (wxGrid *) 0 ;
14959 int arg2 ;
14960 int arg3 ;
14961 wxColour result;
14962 void *argp1 = 0 ;
14963 int res1 = 0 ;
14964 int val2 ;
14965 int ecode2 = 0 ;
14966 int val3 ;
14967 int ecode3 = 0 ;
14968 PyObject * obj0 = 0 ;
14969 PyObject * obj1 = 0 ;
14970 PyObject * obj2 = 0 ;
14971 char * kwnames[] = {
14972 (char *) "self",(char *) "row",(char *) "col", NULL
14973 };
14974
14975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14977 if (!SWIG_IsOK(res1)) {
14978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14979 }
14980 arg1 = reinterpret_cast< wxGrid * >(argp1);
14981 ecode2 = SWIG_AsVal_int(obj1, &val2);
14982 if (!SWIG_IsOK(ecode2)) {
14983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
14984 }
14985 arg2 = static_cast< int >(val2);
14986 ecode3 = SWIG_AsVal_int(obj2, &val3);
14987 if (!SWIG_IsOK(ecode3)) {
14988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
14989 }
14990 arg3 = static_cast< int >(val3);
14991 {
14992 PyThreadState* __tstate = wxPyBeginAllowThreads();
14993 result = (arg1)->GetCellTextColour(arg2,arg3);
14994 wxPyEndAllowThreads(__tstate);
14995 if (PyErr_Occurred()) SWIG_fail;
14996 }
14997 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14998 return resultobj;
14999 fail:
15000 return NULL;
15001 }
15002
15003
15004 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15005 PyObject *resultobj = 0;
15006 wxGrid *arg1 = (wxGrid *) 0 ;
15007 wxFont result;
15008 void *argp1 = 0 ;
15009 int res1 = 0 ;
15010 PyObject *swig_obj[1] ;
15011
15012 if (!args) SWIG_fail;
15013 swig_obj[0] = args;
15014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15015 if (!SWIG_IsOK(res1)) {
15016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15017 }
15018 arg1 = reinterpret_cast< wxGrid * >(argp1);
15019 {
15020 PyThreadState* __tstate = wxPyBeginAllowThreads();
15021 result = (arg1)->GetDefaultCellFont();
15022 wxPyEndAllowThreads(__tstate);
15023 if (PyErr_Occurred()) SWIG_fail;
15024 }
15025 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15026 return resultobj;
15027 fail:
15028 return NULL;
15029 }
15030
15031
15032 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15033 PyObject *resultobj = 0;
15034 wxGrid *arg1 = (wxGrid *) 0 ;
15035 int arg2 ;
15036 int arg3 ;
15037 wxFont result;
15038 void *argp1 = 0 ;
15039 int res1 = 0 ;
15040 int val2 ;
15041 int ecode2 = 0 ;
15042 int val3 ;
15043 int ecode3 = 0 ;
15044 PyObject * obj0 = 0 ;
15045 PyObject * obj1 = 0 ;
15046 PyObject * obj2 = 0 ;
15047 char * kwnames[] = {
15048 (char *) "self",(char *) "row",(char *) "col", NULL
15049 };
15050
15051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15053 if (!SWIG_IsOK(res1)) {
15054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15055 }
15056 arg1 = reinterpret_cast< wxGrid * >(argp1);
15057 ecode2 = SWIG_AsVal_int(obj1, &val2);
15058 if (!SWIG_IsOK(ecode2)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15060 }
15061 arg2 = static_cast< int >(val2);
15062 ecode3 = SWIG_AsVal_int(obj2, &val3);
15063 if (!SWIG_IsOK(ecode3)) {
15064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15065 }
15066 arg3 = static_cast< int >(val3);
15067 {
15068 PyThreadState* __tstate = wxPyBeginAllowThreads();
15069 result = (arg1)->GetCellFont(arg2,arg3);
15070 wxPyEndAllowThreads(__tstate);
15071 if (PyErr_Occurred()) SWIG_fail;
15072 }
15073 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15074 return resultobj;
15075 fail:
15076 return NULL;
15077 }
15078
15079
15080 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15081 PyObject *resultobj = 0;
15082 wxGrid *arg1 = (wxGrid *) 0 ;
15083 int *arg2 = (int *) 0 ;
15084 int *arg3 = (int *) 0 ;
15085 void *argp1 = 0 ;
15086 int res1 = 0 ;
15087 int temp2 ;
15088 int res2 = SWIG_TMPOBJ ;
15089 int temp3 ;
15090 int res3 = SWIG_TMPOBJ ;
15091 PyObject *swig_obj[1] ;
15092
15093 arg2 = &temp2;
15094 arg3 = &temp3;
15095 if (!args) SWIG_fail;
15096 swig_obj[0] = args;
15097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15098 if (!SWIG_IsOK(res1)) {
15099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15100 }
15101 arg1 = reinterpret_cast< wxGrid * >(argp1);
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15105 wxPyEndAllowThreads(__tstate);
15106 if (PyErr_Occurred()) SWIG_fail;
15107 }
15108 resultobj = SWIG_Py_Void();
15109 if (SWIG_IsTmpObj(res2)) {
15110 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15111 } else {
15112 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15113 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15114 }
15115 if (SWIG_IsTmpObj(res3)) {
15116 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15117 } else {
15118 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15119 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15120 }
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15128 PyObject *resultobj = 0;
15129 wxGrid *arg1 = (wxGrid *) 0 ;
15130 int arg2 ;
15131 int arg3 ;
15132 int *arg4 = (int *) 0 ;
15133 int *arg5 = (int *) 0 ;
15134 void *argp1 = 0 ;
15135 int res1 = 0 ;
15136 int val2 ;
15137 int ecode2 = 0 ;
15138 int val3 ;
15139 int ecode3 = 0 ;
15140 int temp4 ;
15141 int res4 = SWIG_TMPOBJ ;
15142 int temp5 ;
15143 int res5 = SWIG_TMPOBJ ;
15144 PyObject * obj0 = 0 ;
15145 PyObject * obj1 = 0 ;
15146 PyObject * obj2 = 0 ;
15147 char * kwnames[] = {
15148 (char *) "self",(char *) "row",(char *) "col", NULL
15149 };
15150
15151 arg4 = &temp4;
15152 arg5 = &temp5;
15153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15155 if (!SWIG_IsOK(res1)) {
15156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15157 }
15158 arg1 = reinterpret_cast< wxGrid * >(argp1);
15159 ecode2 = SWIG_AsVal_int(obj1, &val2);
15160 if (!SWIG_IsOK(ecode2)) {
15161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15162 }
15163 arg2 = static_cast< int >(val2);
15164 ecode3 = SWIG_AsVal_int(obj2, &val3);
15165 if (!SWIG_IsOK(ecode3)) {
15166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15167 }
15168 arg3 = static_cast< int >(val3);
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_Py_Void();
15176 if (SWIG_IsTmpObj(res4)) {
15177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15178 } else {
15179 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15181 }
15182 if (SWIG_IsTmpObj(res5)) {
15183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15184 } else {
15185 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15187 }
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195 PyObject *resultobj = 0;
15196 wxGrid *arg1 = (wxGrid *) 0 ;
15197 bool result;
15198 void *argp1 = 0 ;
15199 int res1 = 0 ;
15200 PyObject *swig_obj[1] ;
15201
15202 if (!args) SWIG_fail;
15203 swig_obj[0] = args;
15204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15205 if (!SWIG_IsOK(res1)) {
15206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15207 }
15208 arg1 = reinterpret_cast< wxGrid * >(argp1);
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 result = (bool)(arg1)->GetDefaultCellOverflow();
15212 wxPyEndAllowThreads(__tstate);
15213 if (PyErr_Occurred()) SWIG_fail;
15214 }
15215 {
15216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15217 }
15218 return resultobj;
15219 fail:
15220 return NULL;
15221 }
15222
15223
15224 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15225 PyObject *resultobj = 0;
15226 wxGrid *arg1 = (wxGrid *) 0 ;
15227 int arg2 ;
15228 int arg3 ;
15229 bool result;
15230 void *argp1 = 0 ;
15231 int res1 = 0 ;
15232 int val2 ;
15233 int ecode2 = 0 ;
15234 int val3 ;
15235 int ecode3 = 0 ;
15236 PyObject * obj0 = 0 ;
15237 PyObject * obj1 = 0 ;
15238 PyObject * obj2 = 0 ;
15239 char * kwnames[] = {
15240 (char *) "self",(char *) "row",(char *) "col", NULL
15241 };
15242
15243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15245 if (!SWIG_IsOK(res1)) {
15246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15247 }
15248 arg1 = reinterpret_cast< wxGrid * >(argp1);
15249 ecode2 = SWIG_AsVal_int(obj1, &val2);
15250 if (!SWIG_IsOK(ecode2)) {
15251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15252 }
15253 arg2 = static_cast< int >(val2);
15254 ecode3 = SWIG_AsVal_int(obj2, &val3);
15255 if (!SWIG_IsOK(ecode3)) {
15256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15257 }
15258 arg3 = static_cast< int >(val3);
15259 {
15260 PyThreadState* __tstate = wxPyBeginAllowThreads();
15261 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 {
15266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15267 }
15268 return resultobj;
15269 fail:
15270 return NULL;
15271 }
15272
15273
15274 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15275 PyObject *resultobj = 0;
15276 wxGrid *arg1 = (wxGrid *) 0 ;
15277 int arg2 ;
15278 int arg3 ;
15279 int *arg4 = (int *) 0 ;
15280 int *arg5 = (int *) 0 ;
15281 void *argp1 = 0 ;
15282 int res1 = 0 ;
15283 int val2 ;
15284 int ecode2 = 0 ;
15285 int val3 ;
15286 int ecode3 = 0 ;
15287 int temp4 ;
15288 int res4 = SWIG_TMPOBJ ;
15289 int temp5 ;
15290 int res5 = SWIG_TMPOBJ ;
15291 PyObject * obj0 = 0 ;
15292 PyObject * obj1 = 0 ;
15293 PyObject * obj2 = 0 ;
15294 char * kwnames[] = {
15295 (char *) "self",(char *) "row",(char *) "col", NULL
15296 };
15297
15298 arg4 = &temp4;
15299 arg5 = &temp5;
15300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15302 if (!SWIG_IsOK(res1)) {
15303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15304 }
15305 arg1 = reinterpret_cast< wxGrid * >(argp1);
15306 ecode2 = SWIG_AsVal_int(obj1, &val2);
15307 if (!SWIG_IsOK(ecode2)) {
15308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15309 }
15310 arg2 = static_cast< int >(val2);
15311 ecode3 = SWIG_AsVal_int(obj2, &val3);
15312 if (!SWIG_IsOK(ecode3)) {
15313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15314 }
15315 arg3 = static_cast< int >(val3);
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 resultobj = SWIG_Py_Void();
15323 if (SWIG_IsTmpObj(res4)) {
15324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15325 } else {
15326 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15328 }
15329 if (SWIG_IsTmpObj(res5)) {
15330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15331 } else {
15332 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15334 }
15335 return resultobj;
15336 fail:
15337 return NULL;
15338 }
15339
15340
15341 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15342 PyObject *resultobj = 0;
15343 wxGrid *arg1 = (wxGrid *) 0 ;
15344 int arg2 ;
15345 bool arg3 = (bool) false ;
15346 void *argp1 = 0 ;
15347 int res1 = 0 ;
15348 int val2 ;
15349 int ecode2 = 0 ;
15350 bool val3 ;
15351 int ecode3 = 0 ;
15352 PyObject * obj0 = 0 ;
15353 PyObject * obj1 = 0 ;
15354 PyObject * obj2 = 0 ;
15355 char * kwnames[] = {
15356 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15357 };
15358
15359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15363 }
15364 arg1 = reinterpret_cast< wxGrid * >(argp1);
15365 ecode2 = SWIG_AsVal_int(obj1, &val2);
15366 if (!SWIG_IsOK(ecode2)) {
15367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15368 }
15369 arg2 = static_cast< int >(val2);
15370 if (obj2) {
15371 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15372 if (!SWIG_IsOK(ecode3)) {
15373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15374 }
15375 arg3 = static_cast< bool >(val3);
15376 }
15377 {
15378 PyThreadState* __tstate = wxPyBeginAllowThreads();
15379 (arg1)->SetDefaultRowSize(arg2,arg3);
15380 wxPyEndAllowThreads(__tstate);
15381 if (PyErr_Occurred()) SWIG_fail;
15382 }
15383 resultobj = SWIG_Py_Void();
15384 return resultobj;
15385 fail:
15386 return NULL;
15387 }
15388
15389
15390 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15391 PyObject *resultobj = 0;
15392 wxGrid *arg1 = (wxGrid *) 0 ;
15393 int arg2 ;
15394 int arg3 ;
15395 void *argp1 = 0 ;
15396 int res1 = 0 ;
15397 int val2 ;
15398 int ecode2 = 0 ;
15399 int val3 ;
15400 int ecode3 = 0 ;
15401 PyObject * obj0 = 0 ;
15402 PyObject * obj1 = 0 ;
15403 PyObject * obj2 = 0 ;
15404 char * kwnames[] = {
15405 (char *) "self",(char *) "row",(char *) "height", NULL
15406 };
15407
15408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15412 }
15413 arg1 = reinterpret_cast< wxGrid * >(argp1);
15414 ecode2 = SWIG_AsVal_int(obj1, &val2);
15415 if (!SWIG_IsOK(ecode2)) {
15416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15417 }
15418 arg2 = static_cast< int >(val2);
15419 ecode3 = SWIG_AsVal_int(obj2, &val3);
15420 if (!SWIG_IsOK(ecode3)) {
15421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15422 }
15423 arg3 = static_cast< int >(val3);
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 (arg1)->SetRowSize(arg2,arg3);
15427 wxPyEndAllowThreads(__tstate);
15428 if (PyErr_Occurred()) SWIG_fail;
15429 }
15430 resultobj = SWIG_Py_Void();
15431 return resultobj;
15432 fail:
15433 return NULL;
15434 }
15435
15436
15437 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15438 PyObject *resultobj = 0;
15439 wxGrid *arg1 = (wxGrid *) 0 ;
15440 int arg2 ;
15441 bool arg3 = (bool) false ;
15442 void *argp1 = 0 ;
15443 int res1 = 0 ;
15444 int val2 ;
15445 int ecode2 = 0 ;
15446 bool val3 ;
15447 int ecode3 = 0 ;
15448 PyObject * obj0 = 0 ;
15449 PyObject * obj1 = 0 ;
15450 PyObject * obj2 = 0 ;
15451 char * kwnames[] = {
15452 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15453 };
15454
15455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15459 }
15460 arg1 = reinterpret_cast< wxGrid * >(argp1);
15461 ecode2 = SWIG_AsVal_int(obj1, &val2);
15462 if (!SWIG_IsOK(ecode2)) {
15463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15464 }
15465 arg2 = static_cast< int >(val2);
15466 if (obj2) {
15467 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15468 if (!SWIG_IsOK(ecode3)) {
15469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15470 }
15471 arg3 = static_cast< bool >(val3);
15472 }
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 (arg1)->SetDefaultColSize(arg2,arg3);
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = SWIG_Py_Void();
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxGrid *arg1 = (wxGrid *) 0 ;
15489 int arg2 ;
15490 int arg3 ;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 int val2 ;
15494 int ecode2 = 0 ;
15495 int val3 ;
15496 int ecode3 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 PyObject * obj2 = 0 ;
15500 char * kwnames[] = {
15501 (char *) "self",(char *) "col",(char *) "width", NULL
15502 };
15503
15504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15506 if (!SWIG_IsOK(res1)) {
15507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15508 }
15509 arg1 = reinterpret_cast< wxGrid * >(argp1);
15510 ecode2 = SWIG_AsVal_int(obj1, &val2);
15511 if (!SWIG_IsOK(ecode2)) {
15512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15513 }
15514 arg2 = static_cast< int >(val2);
15515 ecode3 = SWIG_AsVal_int(obj2, &val3);
15516 if (!SWIG_IsOK(ecode3)) {
15517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15518 }
15519 arg3 = static_cast< int >(val3);
15520 {
15521 PyThreadState* __tstate = wxPyBeginAllowThreads();
15522 (arg1)->SetColSize(arg2,arg3);
15523 wxPyEndAllowThreads(__tstate);
15524 if (PyErr_Occurred()) SWIG_fail;
15525 }
15526 resultobj = SWIG_Py_Void();
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15534 PyObject *resultobj = 0;
15535 wxGrid *arg1 = (wxGrid *) 0 ;
15536 int arg2 ;
15537 int result;
15538 void *argp1 = 0 ;
15539 int res1 = 0 ;
15540 int val2 ;
15541 int ecode2 = 0 ;
15542 PyObject * obj0 = 0 ;
15543 PyObject * obj1 = 0 ;
15544 char * kwnames[] = {
15545 (char *) "self",(char *) "colPos", NULL
15546 };
15547
15548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15550 if (!SWIG_IsOK(res1)) {
15551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15552 }
15553 arg1 = reinterpret_cast< wxGrid * >(argp1);
15554 ecode2 = SWIG_AsVal_int(obj1, &val2);
15555 if (!SWIG_IsOK(ecode2)) {
15556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15557 }
15558 arg2 = static_cast< int >(val2);
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_From_int(static_cast< int >(result));
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15573 PyObject *resultobj = 0;
15574 wxGrid *arg1 = (wxGrid *) 0 ;
15575 int arg2 ;
15576 int arg3 ;
15577 void *argp1 = 0 ;
15578 int res1 = 0 ;
15579 int val2 ;
15580 int ecode2 = 0 ;
15581 int val3 ;
15582 int ecode3 = 0 ;
15583 PyObject * obj0 = 0 ;
15584 PyObject * obj1 = 0 ;
15585 PyObject * obj2 = 0 ;
15586 char * kwnames[] = {
15587 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15588 };
15589
15590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15592 if (!SWIG_IsOK(res1)) {
15593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15594 }
15595 arg1 = reinterpret_cast< wxGrid * >(argp1);
15596 ecode2 = SWIG_AsVal_int(obj1, &val2);
15597 if (!SWIG_IsOK(ecode2)) {
15598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15599 }
15600 arg2 = static_cast< int >(val2);
15601 ecode3 = SWIG_AsVal_int(obj2, &val3);
15602 if (!SWIG_IsOK(ecode3)) {
15603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15604 }
15605 arg3 = static_cast< int >(val3);
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 (arg1)->SetColPos(arg2,arg3);
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 resultobj = SWIG_Py_Void();
15613 return resultobj;
15614 fail:
15615 return NULL;
15616 }
15617
15618
15619 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15620 PyObject *resultobj = 0;
15621 wxGrid *arg1 = (wxGrid *) 0 ;
15622 int arg2 ;
15623 int result;
15624 void *argp1 = 0 ;
15625 int res1 = 0 ;
15626 int val2 ;
15627 int ecode2 = 0 ;
15628 PyObject * obj0 = 0 ;
15629 PyObject * obj1 = 0 ;
15630 char * kwnames[] = {
15631 (char *) "self",(char *) "colID", NULL
15632 };
15633
15634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
15635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15636 if (!SWIG_IsOK(res1)) {
15637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
15638 }
15639 arg1 = reinterpret_cast< wxGrid * >(argp1);
15640 ecode2 = SWIG_AsVal_int(obj1, &val2);
15641 if (!SWIG_IsOK(ecode2)) {
15642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
15643 }
15644 arg2 = static_cast< int >(val2);
15645 {
15646 PyThreadState* __tstate = wxPyBeginAllowThreads();
15647 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
15648 wxPyEndAllowThreads(__tstate);
15649 if (PyErr_Occurred()) SWIG_fail;
15650 }
15651 resultobj = SWIG_From_int(static_cast< int >(result));
15652 return resultobj;
15653 fail:
15654 return NULL;
15655 }
15656
15657
15658 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15659 PyObject *resultobj = 0;
15660 wxGrid *arg1 = (wxGrid *) 0 ;
15661 int arg2 ;
15662 bool arg3 = (bool) true ;
15663 void *argp1 = 0 ;
15664 int res1 = 0 ;
15665 int val2 ;
15666 int ecode2 = 0 ;
15667 bool val3 ;
15668 int ecode3 = 0 ;
15669 PyObject * obj0 = 0 ;
15670 PyObject * obj1 = 0 ;
15671 PyObject * obj2 = 0 ;
15672 char * kwnames[] = {
15673 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15674 };
15675
15676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15678 if (!SWIG_IsOK(res1)) {
15679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15680 }
15681 arg1 = reinterpret_cast< wxGrid * >(argp1);
15682 ecode2 = SWIG_AsVal_int(obj1, &val2);
15683 if (!SWIG_IsOK(ecode2)) {
15684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15685 }
15686 arg2 = static_cast< int >(val2);
15687 if (obj2) {
15688 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15689 if (!SWIG_IsOK(ecode3)) {
15690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15691 }
15692 arg3 = static_cast< bool >(val3);
15693 }
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 (arg1)->AutoSizeColumn(arg2,arg3);
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_Py_Void();
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15708 PyObject *resultobj = 0;
15709 wxGrid *arg1 = (wxGrid *) 0 ;
15710 int arg2 ;
15711 bool arg3 = (bool) true ;
15712 void *argp1 = 0 ;
15713 int res1 = 0 ;
15714 int val2 ;
15715 int ecode2 = 0 ;
15716 bool val3 ;
15717 int ecode3 = 0 ;
15718 PyObject * obj0 = 0 ;
15719 PyObject * obj1 = 0 ;
15720 PyObject * obj2 = 0 ;
15721 char * kwnames[] = {
15722 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15723 };
15724
15725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15727 if (!SWIG_IsOK(res1)) {
15728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15729 }
15730 arg1 = reinterpret_cast< wxGrid * >(argp1);
15731 ecode2 = SWIG_AsVal_int(obj1, &val2);
15732 if (!SWIG_IsOK(ecode2)) {
15733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15734 }
15735 arg2 = static_cast< int >(val2);
15736 if (obj2) {
15737 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15738 if (!SWIG_IsOK(ecode3)) {
15739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15740 }
15741 arg3 = static_cast< bool >(val3);
15742 }
15743 {
15744 PyThreadState* __tstate = wxPyBeginAllowThreads();
15745 (arg1)->AutoSizeRow(arg2,arg3);
15746 wxPyEndAllowThreads(__tstate);
15747 if (PyErr_Occurred()) SWIG_fail;
15748 }
15749 resultobj = SWIG_Py_Void();
15750 return resultobj;
15751 fail:
15752 return NULL;
15753 }
15754
15755
15756 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15757 PyObject *resultobj = 0;
15758 wxGrid *arg1 = (wxGrid *) 0 ;
15759 bool arg2 = (bool) true ;
15760 void *argp1 = 0 ;
15761 int res1 = 0 ;
15762 bool val2 ;
15763 int ecode2 = 0 ;
15764 PyObject * obj0 = 0 ;
15765 PyObject * obj1 = 0 ;
15766 char * kwnames[] = {
15767 (char *) "self",(char *) "setAsMin", NULL
15768 };
15769
15770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15772 if (!SWIG_IsOK(res1)) {
15773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15774 }
15775 arg1 = reinterpret_cast< wxGrid * >(argp1);
15776 if (obj1) {
15777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15778 if (!SWIG_IsOK(ecode2)) {
15779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15780 }
15781 arg2 = static_cast< bool >(val2);
15782 }
15783 {
15784 PyThreadState* __tstate = wxPyBeginAllowThreads();
15785 (arg1)->AutoSizeColumns(arg2);
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 resultobj = SWIG_Py_Void();
15790 return resultobj;
15791 fail:
15792 return NULL;
15793 }
15794
15795
15796 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15797 PyObject *resultobj = 0;
15798 wxGrid *arg1 = (wxGrid *) 0 ;
15799 bool arg2 = (bool) true ;
15800 void *argp1 = 0 ;
15801 int res1 = 0 ;
15802 bool val2 ;
15803 int ecode2 = 0 ;
15804 PyObject * obj0 = 0 ;
15805 PyObject * obj1 = 0 ;
15806 char * kwnames[] = {
15807 (char *) "self",(char *) "setAsMin", NULL
15808 };
15809
15810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15814 }
15815 arg1 = reinterpret_cast< wxGrid * >(argp1);
15816 if (obj1) {
15817 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15818 if (!SWIG_IsOK(ecode2)) {
15819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15820 }
15821 arg2 = static_cast< bool >(val2);
15822 }
15823 {
15824 PyThreadState* __tstate = wxPyBeginAllowThreads();
15825 (arg1)->AutoSizeRows(arg2);
15826 wxPyEndAllowThreads(__tstate);
15827 if (PyErr_Occurred()) SWIG_fail;
15828 }
15829 resultobj = SWIG_Py_Void();
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15837 PyObject *resultobj = 0;
15838 wxGrid *arg1 = (wxGrid *) 0 ;
15839 void *argp1 = 0 ;
15840 int res1 = 0 ;
15841 PyObject *swig_obj[1] ;
15842
15843 if (!args) SWIG_fail;
15844 swig_obj[0] = args;
15845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15846 if (!SWIG_IsOK(res1)) {
15847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15848 }
15849 arg1 = reinterpret_cast< wxGrid * >(argp1);
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 (arg1)->AutoSize();
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 resultobj = SWIG_Py_Void();
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj = 0;
15865 wxGrid *arg1 = (wxGrid *) 0 ;
15866 int arg2 ;
15867 void *argp1 = 0 ;
15868 int res1 = 0 ;
15869 int val2 ;
15870 int ecode2 = 0 ;
15871 PyObject * obj0 = 0 ;
15872 PyObject * obj1 = 0 ;
15873 char * kwnames[] = {
15874 (char *) "self",(char *) "row", NULL
15875 };
15876
15877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15879 if (!SWIG_IsOK(res1)) {
15880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15881 }
15882 arg1 = reinterpret_cast< wxGrid * >(argp1);
15883 ecode2 = SWIG_AsVal_int(obj1, &val2);
15884 if (!SWIG_IsOK(ecode2)) {
15885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15886 }
15887 arg2 = static_cast< int >(val2);
15888 {
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 (arg1)->AutoSizeRowLabelSize(arg2);
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 resultobj = SWIG_Py_Void();
15895 return resultobj;
15896 fail:
15897 return NULL;
15898 }
15899
15900
15901 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15902 PyObject *resultobj = 0;
15903 wxGrid *arg1 = (wxGrid *) 0 ;
15904 int arg2 ;
15905 void *argp1 = 0 ;
15906 int res1 = 0 ;
15907 int val2 ;
15908 int ecode2 = 0 ;
15909 PyObject * obj0 = 0 ;
15910 PyObject * obj1 = 0 ;
15911 char * kwnames[] = {
15912 (char *) "self",(char *) "col", NULL
15913 };
15914
15915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15917 if (!SWIG_IsOK(res1)) {
15918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15919 }
15920 arg1 = reinterpret_cast< wxGrid * >(argp1);
15921 ecode2 = SWIG_AsVal_int(obj1, &val2);
15922 if (!SWIG_IsOK(ecode2)) {
15923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
15924 }
15925 arg2 = static_cast< int >(val2);
15926 {
15927 PyThreadState* __tstate = wxPyBeginAllowThreads();
15928 (arg1)->AutoSizeColLabelSize(arg2);
15929 wxPyEndAllowThreads(__tstate);
15930 if (PyErr_Occurred()) SWIG_fail;
15931 }
15932 resultobj = SWIG_Py_Void();
15933 return resultobj;
15934 fail:
15935 return NULL;
15936 }
15937
15938
15939 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15940 PyObject *resultobj = 0;
15941 wxGrid *arg1 = (wxGrid *) 0 ;
15942 int arg2 ;
15943 int arg3 ;
15944 void *argp1 = 0 ;
15945 int res1 = 0 ;
15946 int val2 ;
15947 int ecode2 = 0 ;
15948 int val3 ;
15949 int ecode3 = 0 ;
15950 PyObject * obj0 = 0 ;
15951 PyObject * obj1 = 0 ;
15952 PyObject * obj2 = 0 ;
15953 char * kwnames[] = {
15954 (char *) "self",(char *) "col",(char *) "width", NULL
15955 };
15956
15957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15959 if (!SWIG_IsOK(res1)) {
15960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15961 }
15962 arg1 = reinterpret_cast< wxGrid * >(argp1);
15963 ecode2 = SWIG_AsVal_int(obj1, &val2);
15964 if (!SWIG_IsOK(ecode2)) {
15965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
15966 }
15967 arg2 = static_cast< int >(val2);
15968 ecode3 = SWIG_AsVal_int(obj2, &val3);
15969 if (!SWIG_IsOK(ecode3)) {
15970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
15971 }
15972 arg3 = static_cast< int >(val3);
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 (arg1)->SetColMinimalWidth(arg2,arg3);
15976 wxPyEndAllowThreads(__tstate);
15977 if (PyErr_Occurred()) SWIG_fail;
15978 }
15979 resultobj = SWIG_Py_Void();
15980 return resultobj;
15981 fail:
15982 return NULL;
15983 }
15984
15985
15986 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15987 PyObject *resultobj = 0;
15988 wxGrid *arg1 = (wxGrid *) 0 ;
15989 int arg2 ;
15990 int arg3 ;
15991 void *argp1 = 0 ;
15992 int res1 = 0 ;
15993 int val2 ;
15994 int ecode2 = 0 ;
15995 int val3 ;
15996 int ecode3 = 0 ;
15997 PyObject * obj0 = 0 ;
15998 PyObject * obj1 = 0 ;
15999 PyObject * obj2 = 0 ;
16000 char * kwnames[] = {
16001 (char *) "self",(char *) "row",(char *) "width", NULL
16002 };
16003
16004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16006 if (!SWIG_IsOK(res1)) {
16007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16008 }
16009 arg1 = reinterpret_cast< wxGrid * >(argp1);
16010 ecode2 = SWIG_AsVal_int(obj1, &val2);
16011 if (!SWIG_IsOK(ecode2)) {
16012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16013 }
16014 arg2 = static_cast< int >(val2);
16015 ecode3 = SWIG_AsVal_int(obj2, &val3);
16016 if (!SWIG_IsOK(ecode3)) {
16017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16018 }
16019 arg3 = static_cast< int >(val3);
16020 {
16021 PyThreadState* __tstate = wxPyBeginAllowThreads();
16022 (arg1)->SetRowMinimalHeight(arg2,arg3);
16023 wxPyEndAllowThreads(__tstate);
16024 if (PyErr_Occurred()) SWIG_fail;
16025 }
16026 resultobj = SWIG_Py_Void();
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj = 0;
16035 wxGrid *arg1 = (wxGrid *) 0 ;
16036 int arg2 ;
16037 void *argp1 = 0 ;
16038 int res1 = 0 ;
16039 int val2 ;
16040 int ecode2 = 0 ;
16041 PyObject * obj0 = 0 ;
16042 PyObject * obj1 = 0 ;
16043 char * kwnames[] = {
16044 (char *) "self",(char *) "width", NULL
16045 };
16046
16047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16049 if (!SWIG_IsOK(res1)) {
16050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16051 }
16052 arg1 = reinterpret_cast< wxGrid * >(argp1);
16053 ecode2 = SWIG_AsVal_int(obj1, &val2);
16054 if (!SWIG_IsOK(ecode2)) {
16055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16056 }
16057 arg2 = static_cast< int >(val2);
16058 {
16059 PyThreadState* __tstate = wxPyBeginAllowThreads();
16060 (arg1)->SetColMinimalAcceptableWidth(arg2);
16061 wxPyEndAllowThreads(__tstate);
16062 if (PyErr_Occurred()) SWIG_fail;
16063 }
16064 resultobj = SWIG_Py_Void();
16065 return resultobj;
16066 fail:
16067 return NULL;
16068 }
16069
16070
16071 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16072 PyObject *resultobj = 0;
16073 wxGrid *arg1 = (wxGrid *) 0 ;
16074 int arg2 ;
16075 void *argp1 = 0 ;
16076 int res1 = 0 ;
16077 int val2 ;
16078 int ecode2 = 0 ;
16079 PyObject * obj0 = 0 ;
16080 PyObject * obj1 = 0 ;
16081 char * kwnames[] = {
16082 (char *) "self",(char *) "width", NULL
16083 };
16084
16085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16087 if (!SWIG_IsOK(res1)) {
16088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16089 }
16090 arg1 = reinterpret_cast< wxGrid * >(argp1);
16091 ecode2 = SWIG_AsVal_int(obj1, &val2);
16092 if (!SWIG_IsOK(ecode2)) {
16093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16094 }
16095 arg2 = static_cast< int >(val2);
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 resultobj = SWIG_Py_Void();
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16110 PyObject *resultobj = 0;
16111 wxGrid *arg1 = (wxGrid *) 0 ;
16112 int result;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 PyObject *swig_obj[1] ;
16116
16117 if (!args) SWIG_fail;
16118 swig_obj[0] = args;
16119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16120 if (!SWIG_IsOK(res1)) {
16121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16122 }
16123 arg1 = reinterpret_cast< wxGrid * >(argp1);
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 resultobj = SWIG_From_int(static_cast< int >(result));
16131 return resultobj;
16132 fail:
16133 return NULL;
16134 }
16135
16136
16137 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16138 PyObject *resultobj = 0;
16139 wxGrid *arg1 = (wxGrid *) 0 ;
16140 int result;
16141 void *argp1 = 0 ;
16142 int res1 = 0 ;
16143 PyObject *swig_obj[1] ;
16144
16145 if (!args) SWIG_fail;
16146 swig_obj[0] = args;
16147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16148 if (!SWIG_IsOK(res1)) {
16149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16150 }
16151 arg1 = reinterpret_cast< wxGrid * >(argp1);
16152 {
16153 PyThreadState* __tstate = wxPyBeginAllowThreads();
16154 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 resultobj = SWIG_From_int(static_cast< int >(result));
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj = 0;
16167 wxGrid *arg1 = (wxGrid *) 0 ;
16168 wxColour *arg2 = 0 ;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 wxColour temp2 ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *)"arg2", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16182 }
16183 arg1 = reinterpret_cast< wxGrid * >(argp1);
16184 {
16185 arg2 = &temp2;
16186 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16187 }
16188 {
16189 PyThreadState* __tstate = wxPyBeginAllowThreads();
16190 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16191 wxPyEndAllowThreads(__tstate);
16192 if (PyErr_Occurred()) SWIG_fail;
16193 }
16194 resultobj = SWIG_Py_Void();
16195 return resultobj;
16196 fail:
16197 return NULL;
16198 }
16199
16200
16201 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16202 PyObject *resultobj = 0;
16203 wxGrid *arg1 = (wxGrid *) 0 ;
16204 int arg2 ;
16205 int arg3 ;
16206 wxColour *arg4 = 0 ;
16207 void *argp1 = 0 ;
16208 int res1 = 0 ;
16209 int val2 ;
16210 int ecode2 = 0 ;
16211 int val3 ;
16212 int ecode3 = 0 ;
16213 wxColour temp4 ;
16214 PyObject * obj0 = 0 ;
16215 PyObject * obj1 = 0 ;
16216 PyObject * obj2 = 0 ;
16217 PyObject * obj3 = 0 ;
16218 char * kwnames[] = {
16219 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16220 };
16221
16222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16226 }
16227 arg1 = reinterpret_cast< wxGrid * >(argp1);
16228 ecode2 = SWIG_AsVal_int(obj1, &val2);
16229 if (!SWIG_IsOK(ecode2)) {
16230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16231 }
16232 arg2 = static_cast< int >(val2);
16233 ecode3 = SWIG_AsVal_int(obj2, &val3);
16234 if (!SWIG_IsOK(ecode3)) {
16235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16236 }
16237 arg3 = static_cast< int >(val3);
16238 {
16239 arg4 = &temp4;
16240 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16241 }
16242 {
16243 PyThreadState* __tstate = wxPyBeginAllowThreads();
16244 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16245 wxPyEndAllowThreads(__tstate);
16246 if (PyErr_Occurred()) SWIG_fail;
16247 }
16248 resultobj = SWIG_Py_Void();
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj = 0;
16257 wxGrid *arg1 = (wxGrid *) 0 ;
16258 wxColour *arg2 = 0 ;
16259 void *argp1 = 0 ;
16260 int res1 = 0 ;
16261 wxColour temp2 ;
16262 PyObject * obj0 = 0 ;
16263 PyObject * obj1 = 0 ;
16264 char * kwnames[] = {
16265 (char *) "self",(char *)"arg2", NULL
16266 };
16267
16268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16270 if (!SWIG_IsOK(res1)) {
16271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16272 }
16273 arg1 = reinterpret_cast< wxGrid * >(argp1);
16274 {
16275 arg2 = &temp2;
16276 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16277 }
16278 {
16279 PyThreadState* __tstate = wxPyBeginAllowThreads();
16280 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 resultobj = SWIG_Py_Void();
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16292 PyObject *resultobj = 0;
16293 wxGrid *arg1 = (wxGrid *) 0 ;
16294 int arg2 ;
16295 int arg3 ;
16296 wxColour *arg4 = 0 ;
16297 void *argp1 = 0 ;
16298 int res1 = 0 ;
16299 int val2 ;
16300 int ecode2 = 0 ;
16301 int val3 ;
16302 int ecode3 = 0 ;
16303 wxColour temp4 ;
16304 PyObject * obj0 = 0 ;
16305 PyObject * obj1 = 0 ;
16306 PyObject * obj2 = 0 ;
16307 PyObject * obj3 = 0 ;
16308 char * kwnames[] = {
16309 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16310 };
16311
16312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16314 if (!SWIG_IsOK(res1)) {
16315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16316 }
16317 arg1 = reinterpret_cast< wxGrid * >(argp1);
16318 ecode2 = SWIG_AsVal_int(obj1, &val2);
16319 if (!SWIG_IsOK(ecode2)) {
16320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16321 }
16322 arg2 = static_cast< int >(val2);
16323 ecode3 = SWIG_AsVal_int(obj2, &val3);
16324 if (!SWIG_IsOK(ecode3)) {
16325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16326 }
16327 arg3 = static_cast< int >(val3);
16328 {
16329 arg4 = &temp4;
16330 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16331 }
16332 {
16333 PyThreadState* __tstate = wxPyBeginAllowThreads();
16334 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16335 wxPyEndAllowThreads(__tstate);
16336 if (PyErr_Occurred()) SWIG_fail;
16337 }
16338 resultobj = SWIG_Py_Void();
16339 return resultobj;
16340 fail:
16341 return NULL;
16342 }
16343
16344
16345 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16346 PyObject *resultobj = 0;
16347 wxGrid *arg1 = (wxGrid *) 0 ;
16348 wxFont *arg2 = 0 ;
16349 void *argp1 = 0 ;
16350 int res1 = 0 ;
16351 void *argp2 = 0 ;
16352 int res2 = 0 ;
16353 PyObject * obj0 = 0 ;
16354 PyObject * obj1 = 0 ;
16355 char * kwnames[] = {
16356 (char *) "self",(char *)"arg2", NULL
16357 };
16358
16359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16361 if (!SWIG_IsOK(res1)) {
16362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16363 }
16364 arg1 = reinterpret_cast< wxGrid * >(argp1);
16365 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16366 if (!SWIG_IsOK(res2)) {
16367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16368 }
16369 if (!argp2) {
16370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16371 }
16372 arg2 = reinterpret_cast< wxFont * >(argp2);
16373 {
16374 PyThreadState* __tstate = wxPyBeginAllowThreads();
16375 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16376 wxPyEndAllowThreads(__tstate);
16377 if (PyErr_Occurred()) SWIG_fail;
16378 }
16379 resultobj = SWIG_Py_Void();
16380 return resultobj;
16381 fail:
16382 return NULL;
16383 }
16384
16385
16386 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16387 PyObject *resultobj = 0;
16388 wxGrid *arg1 = (wxGrid *) 0 ;
16389 int arg2 ;
16390 int arg3 ;
16391 wxFont *arg4 = 0 ;
16392 void *argp1 = 0 ;
16393 int res1 = 0 ;
16394 int val2 ;
16395 int ecode2 = 0 ;
16396 int val3 ;
16397 int ecode3 = 0 ;
16398 void *argp4 = 0 ;
16399 int res4 = 0 ;
16400 PyObject * obj0 = 0 ;
16401 PyObject * obj1 = 0 ;
16402 PyObject * obj2 = 0 ;
16403 PyObject * obj3 = 0 ;
16404 char * kwnames[] = {
16405 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16406 };
16407
16408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16410 if (!SWIG_IsOK(res1)) {
16411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16412 }
16413 arg1 = reinterpret_cast< wxGrid * >(argp1);
16414 ecode2 = SWIG_AsVal_int(obj1, &val2);
16415 if (!SWIG_IsOK(ecode2)) {
16416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16417 }
16418 arg2 = static_cast< int >(val2);
16419 ecode3 = SWIG_AsVal_int(obj2, &val3);
16420 if (!SWIG_IsOK(ecode3)) {
16421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16422 }
16423 arg3 = static_cast< int >(val3);
16424 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16425 if (!SWIG_IsOK(res4)) {
16426 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16427 }
16428 if (!argp4) {
16429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16430 }
16431 arg4 = reinterpret_cast< wxFont * >(argp4);
16432 {
16433 PyThreadState* __tstate = wxPyBeginAllowThreads();
16434 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 resultobj = SWIG_Py_Void();
16439 return resultobj;
16440 fail:
16441 return NULL;
16442 }
16443
16444
16445 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16446 PyObject *resultobj = 0;
16447 wxGrid *arg1 = (wxGrid *) 0 ;
16448 int arg2 ;
16449 int arg3 ;
16450 void *argp1 = 0 ;
16451 int res1 = 0 ;
16452 int val2 ;
16453 int ecode2 = 0 ;
16454 int val3 ;
16455 int ecode3 = 0 ;
16456 PyObject * obj0 = 0 ;
16457 PyObject * obj1 = 0 ;
16458 PyObject * obj2 = 0 ;
16459 char * kwnames[] = {
16460 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16461 };
16462
16463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16465 if (!SWIG_IsOK(res1)) {
16466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16467 }
16468 arg1 = reinterpret_cast< wxGrid * >(argp1);
16469 ecode2 = SWIG_AsVal_int(obj1, &val2);
16470 if (!SWIG_IsOK(ecode2)) {
16471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16472 }
16473 arg2 = static_cast< int >(val2);
16474 ecode3 = SWIG_AsVal_int(obj2, &val3);
16475 if (!SWIG_IsOK(ecode3)) {
16476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16477 }
16478 arg3 = static_cast< int >(val3);
16479 {
16480 PyThreadState* __tstate = wxPyBeginAllowThreads();
16481 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16482 wxPyEndAllowThreads(__tstate);
16483 if (PyErr_Occurred()) SWIG_fail;
16484 }
16485 resultobj = SWIG_Py_Void();
16486 return resultobj;
16487 fail:
16488 return NULL;
16489 }
16490
16491
16492 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16493 PyObject *resultobj = 0;
16494 wxGrid *arg1 = (wxGrid *) 0 ;
16495 int arg2 ;
16496 int arg3 ;
16497 int arg4 ;
16498 int arg5 ;
16499 void *argp1 = 0 ;
16500 int res1 = 0 ;
16501 int val2 ;
16502 int ecode2 = 0 ;
16503 int val3 ;
16504 int ecode3 = 0 ;
16505 int val4 ;
16506 int ecode4 = 0 ;
16507 int val5 ;
16508 int ecode5 = 0 ;
16509 PyObject * obj0 = 0 ;
16510 PyObject * obj1 = 0 ;
16511 PyObject * obj2 = 0 ;
16512 PyObject * obj3 = 0 ;
16513 PyObject * obj4 = 0 ;
16514 char * kwnames[] = {
16515 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16516 };
16517
16518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16520 if (!SWIG_IsOK(res1)) {
16521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16522 }
16523 arg1 = reinterpret_cast< wxGrid * >(argp1);
16524 ecode2 = SWIG_AsVal_int(obj1, &val2);
16525 if (!SWIG_IsOK(ecode2)) {
16526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16527 }
16528 arg2 = static_cast< int >(val2);
16529 ecode3 = SWIG_AsVal_int(obj2, &val3);
16530 if (!SWIG_IsOK(ecode3)) {
16531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16532 }
16533 arg3 = static_cast< int >(val3);
16534 ecode4 = SWIG_AsVal_int(obj3, &val4);
16535 if (!SWIG_IsOK(ecode4)) {
16536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16537 }
16538 arg4 = static_cast< int >(val4);
16539 ecode5 = SWIG_AsVal_int(obj4, &val5);
16540 if (!SWIG_IsOK(ecode5)) {
16541 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16542 }
16543 arg5 = static_cast< int >(val5);
16544 {
16545 PyThreadState* __tstate = wxPyBeginAllowThreads();
16546 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16547 wxPyEndAllowThreads(__tstate);
16548 if (PyErr_Occurred()) SWIG_fail;
16549 }
16550 resultobj = SWIG_Py_Void();
16551 return resultobj;
16552 fail:
16553 return NULL;
16554 }
16555
16556
16557 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16558 PyObject *resultobj = 0;
16559 wxGrid *arg1 = (wxGrid *) 0 ;
16560 bool arg2 ;
16561 void *argp1 = 0 ;
16562 int res1 = 0 ;
16563 bool val2 ;
16564 int ecode2 = 0 ;
16565 PyObject * obj0 = 0 ;
16566 PyObject * obj1 = 0 ;
16567 char * kwnames[] = {
16568 (char *) "self",(char *) "allow", NULL
16569 };
16570
16571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16573 if (!SWIG_IsOK(res1)) {
16574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16575 }
16576 arg1 = reinterpret_cast< wxGrid * >(argp1);
16577 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16578 if (!SWIG_IsOK(ecode2)) {
16579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16580 }
16581 arg2 = static_cast< bool >(val2);
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 (arg1)->SetDefaultCellOverflow(arg2);
16585 wxPyEndAllowThreads(__tstate);
16586 if (PyErr_Occurred()) SWIG_fail;
16587 }
16588 resultobj = SWIG_Py_Void();
16589 return resultobj;
16590 fail:
16591 return NULL;
16592 }
16593
16594
16595 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16596 PyObject *resultobj = 0;
16597 wxGrid *arg1 = (wxGrid *) 0 ;
16598 int arg2 ;
16599 int arg3 ;
16600 bool arg4 ;
16601 void *argp1 = 0 ;
16602 int res1 = 0 ;
16603 int val2 ;
16604 int ecode2 = 0 ;
16605 int val3 ;
16606 int ecode3 = 0 ;
16607 bool val4 ;
16608 int ecode4 = 0 ;
16609 PyObject * obj0 = 0 ;
16610 PyObject * obj1 = 0 ;
16611 PyObject * obj2 = 0 ;
16612 PyObject * obj3 = 0 ;
16613 char * kwnames[] = {
16614 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16615 };
16616
16617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16619 if (!SWIG_IsOK(res1)) {
16620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16621 }
16622 arg1 = reinterpret_cast< wxGrid * >(argp1);
16623 ecode2 = SWIG_AsVal_int(obj1, &val2);
16624 if (!SWIG_IsOK(ecode2)) {
16625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16626 }
16627 arg2 = static_cast< int >(val2);
16628 ecode3 = SWIG_AsVal_int(obj2, &val3);
16629 if (!SWIG_IsOK(ecode3)) {
16630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16631 }
16632 arg3 = static_cast< int >(val3);
16633 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16634 if (!SWIG_IsOK(ecode4)) {
16635 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16636 }
16637 arg4 = static_cast< bool >(val4);
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 resultobj = SWIG_Py_Void();
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj = 0;
16653 wxGrid *arg1 = (wxGrid *) 0 ;
16654 int arg2 ;
16655 int arg3 ;
16656 int arg4 ;
16657 int arg5 ;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 int val2 ;
16661 int ecode2 = 0 ;
16662 int val3 ;
16663 int ecode3 = 0 ;
16664 int val4 ;
16665 int ecode4 = 0 ;
16666 int val5 ;
16667 int ecode5 = 0 ;
16668 PyObject * obj0 = 0 ;
16669 PyObject * obj1 = 0 ;
16670 PyObject * obj2 = 0 ;
16671 PyObject * obj3 = 0 ;
16672 PyObject * obj4 = 0 ;
16673 char * kwnames[] = {
16674 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16675 };
16676
16677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16679 if (!SWIG_IsOK(res1)) {
16680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16681 }
16682 arg1 = reinterpret_cast< wxGrid * >(argp1);
16683 ecode2 = SWIG_AsVal_int(obj1, &val2);
16684 if (!SWIG_IsOK(ecode2)) {
16685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16686 }
16687 arg2 = static_cast< int >(val2);
16688 ecode3 = SWIG_AsVal_int(obj2, &val3);
16689 if (!SWIG_IsOK(ecode3)) {
16690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16691 }
16692 arg3 = static_cast< int >(val3);
16693 ecode4 = SWIG_AsVal_int(obj3, &val4);
16694 if (!SWIG_IsOK(ecode4)) {
16695 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16696 }
16697 arg4 = static_cast< int >(val4);
16698 ecode5 = SWIG_AsVal_int(obj4, &val5);
16699 if (!SWIG_IsOK(ecode5)) {
16700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16701 }
16702 arg5 = static_cast< int >(val5);
16703 {
16704 PyThreadState* __tstate = wxPyBeginAllowThreads();
16705 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16706 wxPyEndAllowThreads(__tstate);
16707 if (PyErr_Occurred()) SWIG_fail;
16708 }
16709 resultobj = SWIG_Py_Void();
16710 return resultobj;
16711 fail:
16712 return NULL;
16713 }
16714
16715
16716 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16717 PyObject *resultobj = 0;
16718 wxGrid *arg1 = (wxGrid *) 0 ;
16719 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16720 void *argp1 = 0 ;
16721 int res1 = 0 ;
16722 void *argp2 = 0 ;
16723 int res2 = 0 ;
16724 PyObject * obj0 = 0 ;
16725 PyObject * obj1 = 0 ;
16726 char * kwnames[] = {
16727 (char *) "self",(char *) "renderer", NULL
16728 };
16729
16730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16732 if (!SWIG_IsOK(res1)) {
16733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16734 }
16735 arg1 = reinterpret_cast< wxGrid * >(argp1);
16736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16737 if (!SWIG_IsOK(res2)) {
16738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16739 }
16740 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16741 {
16742 PyThreadState* __tstate = wxPyBeginAllowThreads();
16743 (arg1)->SetDefaultRenderer(arg2);
16744 wxPyEndAllowThreads(__tstate);
16745 if (PyErr_Occurred()) SWIG_fail;
16746 }
16747 resultobj = SWIG_Py_Void();
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj = 0;
16756 wxGrid *arg1 = (wxGrid *) 0 ;
16757 int arg2 ;
16758 int arg3 ;
16759 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16760 void *argp1 = 0 ;
16761 int res1 = 0 ;
16762 int val2 ;
16763 int ecode2 = 0 ;
16764 int val3 ;
16765 int ecode3 = 0 ;
16766 void *argp4 = 0 ;
16767 int res4 = 0 ;
16768 PyObject * obj0 = 0 ;
16769 PyObject * obj1 = 0 ;
16770 PyObject * obj2 = 0 ;
16771 PyObject * obj3 = 0 ;
16772 char * kwnames[] = {
16773 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16774 };
16775
16776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16778 if (!SWIG_IsOK(res1)) {
16779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16780 }
16781 arg1 = reinterpret_cast< wxGrid * >(argp1);
16782 ecode2 = SWIG_AsVal_int(obj1, &val2);
16783 if (!SWIG_IsOK(ecode2)) {
16784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16785 }
16786 arg2 = static_cast< int >(val2);
16787 ecode3 = SWIG_AsVal_int(obj2, &val3);
16788 if (!SWIG_IsOK(ecode3)) {
16789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16790 }
16791 arg3 = static_cast< int >(val3);
16792 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16793 if (!SWIG_IsOK(res4)) {
16794 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16795 }
16796 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16797 {
16798 PyThreadState* __tstate = wxPyBeginAllowThreads();
16799 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16800 wxPyEndAllowThreads(__tstate);
16801 if (PyErr_Occurred()) SWIG_fail;
16802 }
16803 resultobj = SWIG_Py_Void();
16804 return resultobj;
16805 fail:
16806 return NULL;
16807 }
16808
16809
16810 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16811 PyObject *resultobj = 0;
16812 wxGrid *arg1 = (wxGrid *) 0 ;
16813 wxGridCellRenderer *result = 0 ;
16814 void *argp1 = 0 ;
16815 int res1 = 0 ;
16816 PyObject *swig_obj[1] ;
16817
16818 if (!args) SWIG_fail;
16819 swig_obj[0] = args;
16820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16821 if (!SWIG_IsOK(res1)) {
16822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16823 }
16824 arg1 = reinterpret_cast< wxGrid * >(argp1);
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16833 }
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj = 0;
16842 wxGrid *arg1 = (wxGrid *) 0 ;
16843 int arg2 ;
16844 int arg3 ;
16845 wxGridCellRenderer *result = 0 ;
16846 void *argp1 = 0 ;
16847 int res1 = 0 ;
16848 int val2 ;
16849 int ecode2 = 0 ;
16850 int val3 ;
16851 int ecode3 = 0 ;
16852 PyObject * obj0 = 0 ;
16853 PyObject * obj1 = 0 ;
16854 PyObject * obj2 = 0 ;
16855 char * kwnames[] = {
16856 (char *) "self",(char *) "row",(char *) "col", NULL
16857 };
16858
16859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16861 if (!SWIG_IsOK(res1)) {
16862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16863 }
16864 arg1 = reinterpret_cast< wxGrid * >(argp1);
16865 ecode2 = SWIG_AsVal_int(obj1, &val2);
16866 if (!SWIG_IsOK(ecode2)) {
16867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16868 }
16869 arg2 = static_cast< int >(val2);
16870 ecode3 = SWIG_AsVal_int(obj2, &val3);
16871 if (!SWIG_IsOK(ecode3)) {
16872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16873 }
16874 arg3 = static_cast< int >(val3);
16875 {
16876 PyThreadState* __tstate = wxPyBeginAllowThreads();
16877 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16878 wxPyEndAllowThreads(__tstate);
16879 if (PyErr_Occurred()) SWIG_fail;
16880 }
16881 {
16882 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16883 }
16884 return resultobj;
16885 fail:
16886 return NULL;
16887 }
16888
16889
16890 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16891 PyObject *resultobj = 0;
16892 wxGrid *arg1 = (wxGrid *) 0 ;
16893 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
16894 void *argp1 = 0 ;
16895 int res1 = 0 ;
16896 void *argp2 = 0 ;
16897 int res2 = 0 ;
16898 PyObject * obj0 = 0 ;
16899 PyObject * obj1 = 0 ;
16900 char * kwnames[] = {
16901 (char *) "self",(char *) "editor", NULL
16902 };
16903
16904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
16905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16906 if (!SWIG_IsOK(res1)) {
16907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16908 }
16909 arg1 = reinterpret_cast< wxGrid * >(argp1);
16910 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16911 if (!SWIG_IsOK(res2)) {
16912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
16913 }
16914 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
16915 {
16916 PyThreadState* __tstate = wxPyBeginAllowThreads();
16917 (arg1)->SetDefaultEditor(arg2);
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 resultobj = SWIG_Py_Void();
16922 return resultobj;
16923 fail:
16924 return NULL;
16925 }
16926
16927
16928 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16929 PyObject *resultobj = 0;
16930 wxGrid *arg1 = (wxGrid *) 0 ;
16931 int arg2 ;
16932 int arg3 ;
16933 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16934 void *argp1 = 0 ;
16935 int res1 = 0 ;
16936 int val2 ;
16937 int ecode2 = 0 ;
16938 int val3 ;
16939 int ecode3 = 0 ;
16940 void *argp4 = 0 ;
16941 int res4 = 0 ;
16942 PyObject * obj0 = 0 ;
16943 PyObject * obj1 = 0 ;
16944 PyObject * obj2 = 0 ;
16945 PyObject * obj3 = 0 ;
16946 char * kwnames[] = {
16947 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
16948 };
16949
16950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16952 if (!SWIG_IsOK(res1)) {
16953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16954 }
16955 arg1 = reinterpret_cast< wxGrid * >(argp1);
16956 ecode2 = SWIG_AsVal_int(obj1, &val2);
16957 if (!SWIG_IsOK(ecode2)) {
16958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
16959 }
16960 arg2 = static_cast< int >(val2);
16961 ecode3 = SWIG_AsVal_int(obj2, &val3);
16962 if (!SWIG_IsOK(ecode3)) {
16963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
16964 }
16965 arg3 = static_cast< int >(val3);
16966 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16967 if (!SWIG_IsOK(res4)) {
16968 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
16969 }
16970 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
16971 {
16972 PyThreadState* __tstate = wxPyBeginAllowThreads();
16973 (arg1)->SetCellEditor(arg2,arg3,arg4);
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 resultobj = SWIG_Py_Void();
16978 return resultobj;
16979 fail:
16980 return NULL;
16981 }
16982
16983
16984 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16985 PyObject *resultobj = 0;
16986 wxGrid *arg1 = (wxGrid *) 0 ;
16987 wxGridCellEditor *result = 0 ;
16988 void *argp1 = 0 ;
16989 int res1 = 0 ;
16990 PyObject *swig_obj[1] ;
16991
16992 if (!args) SWIG_fail;
16993 swig_obj[0] = args;
16994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16995 if (!SWIG_IsOK(res1)) {
16996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
16997 }
16998 arg1 = reinterpret_cast< wxGrid * >(argp1);
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17007 }
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj = 0;
17016 wxGrid *arg1 = (wxGrid *) 0 ;
17017 int arg2 ;
17018 int arg3 ;
17019 wxGridCellEditor *result = 0 ;
17020 void *argp1 = 0 ;
17021 int res1 = 0 ;
17022 int val2 ;
17023 int ecode2 = 0 ;
17024 int val3 ;
17025 int ecode3 = 0 ;
17026 PyObject * obj0 = 0 ;
17027 PyObject * obj1 = 0 ;
17028 PyObject * obj2 = 0 ;
17029 char * kwnames[] = {
17030 (char *) "self",(char *) "row",(char *) "col", NULL
17031 };
17032
17033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17035 if (!SWIG_IsOK(res1)) {
17036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17037 }
17038 arg1 = reinterpret_cast< wxGrid * >(argp1);
17039 ecode2 = SWIG_AsVal_int(obj1, &val2);
17040 if (!SWIG_IsOK(ecode2)) {
17041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17042 }
17043 arg2 = static_cast< int >(val2);
17044 ecode3 = SWIG_AsVal_int(obj2, &val3);
17045 if (!SWIG_IsOK(ecode3)) {
17046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17047 }
17048 arg3 = static_cast< int >(val3);
17049 {
17050 PyThreadState* __tstate = wxPyBeginAllowThreads();
17051 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17052 wxPyEndAllowThreads(__tstate);
17053 if (PyErr_Occurred()) SWIG_fail;
17054 }
17055 {
17056 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17057 }
17058 return resultobj;
17059 fail:
17060 return NULL;
17061 }
17062
17063
17064 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17065 PyObject *resultobj = 0;
17066 wxGrid *arg1 = (wxGrid *) 0 ;
17067 int arg2 ;
17068 int arg3 ;
17069 wxString result;
17070 void *argp1 = 0 ;
17071 int res1 = 0 ;
17072 int val2 ;
17073 int ecode2 = 0 ;
17074 int val3 ;
17075 int ecode3 = 0 ;
17076 PyObject * obj0 = 0 ;
17077 PyObject * obj1 = 0 ;
17078 PyObject * obj2 = 0 ;
17079 char * kwnames[] = {
17080 (char *) "self",(char *) "row",(char *) "col", NULL
17081 };
17082
17083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17085 if (!SWIG_IsOK(res1)) {
17086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17087 }
17088 arg1 = reinterpret_cast< wxGrid * >(argp1);
17089 ecode2 = SWIG_AsVal_int(obj1, &val2);
17090 if (!SWIG_IsOK(ecode2)) {
17091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17092 }
17093 arg2 = static_cast< int >(val2);
17094 ecode3 = SWIG_AsVal_int(obj2, &val3);
17095 if (!SWIG_IsOK(ecode3)) {
17096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17097 }
17098 arg3 = static_cast< int >(val3);
17099 {
17100 PyThreadState* __tstate = wxPyBeginAllowThreads();
17101 result = (arg1)->GetCellValue(arg2,arg3);
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 {
17106 #if wxUSE_UNICODE
17107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17108 #else
17109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17110 #endif
17111 }
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17119 PyObject *resultobj = 0;
17120 wxGrid *arg1 = (wxGrid *) 0 ;
17121 int arg2 ;
17122 int arg3 ;
17123 wxString *arg4 = 0 ;
17124 void *argp1 = 0 ;
17125 int res1 = 0 ;
17126 int val2 ;
17127 int ecode2 = 0 ;
17128 int val3 ;
17129 int ecode3 = 0 ;
17130 bool temp4 = false ;
17131 PyObject * obj0 = 0 ;
17132 PyObject * obj1 = 0 ;
17133 PyObject * obj2 = 0 ;
17134 PyObject * obj3 = 0 ;
17135 char * kwnames[] = {
17136 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17137 };
17138
17139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17141 if (!SWIG_IsOK(res1)) {
17142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17143 }
17144 arg1 = reinterpret_cast< wxGrid * >(argp1);
17145 ecode2 = SWIG_AsVal_int(obj1, &val2);
17146 if (!SWIG_IsOK(ecode2)) {
17147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17148 }
17149 arg2 = static_cast< int >(val2);
17150 ecode3 = SWIG_AsVal_int(obj2, &val3);
17151 if (!SWIG_IsOK(ecode3)) {
17152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17153 }
17154 arg3 = static_cast< int >(val3);
17155 {
17156 arg4 = wxString_in_helper(obj3);
17157 if (arg4 == NULL) SWIG_fail;
17158 temp4 = true;
17159 }
17160 {
17161 PyThreadState* __tstate = wxPyBeginAllowThreads();
17162 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17163 wxPyEndAllowThreads(__tstate);
17164 if (PyErr_Occurred()) SWIG_fail;
17165 }
17166 resultobj = SWIG_Py_Void();
17167 {
17168 if (temp4)
17169 delete arg4;
17170 }
17171 return resultobj;
17172 fail:
17173 {
17174 if (temp4)
17175 delete arg4;
17176 }
17177 return NULL;
17178 }
17179
17180
17181 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj = 0;
17183 wxGrid *arg1 = (wxGrid *) 0 ;
17184 int arg2 ;
17185 int arg3 ;
17186 bool result;
17187 void *argp1 = 0 ;
17188 int res1 = 0 ;
17189 int val2 ;
17190 int ecode2 = 0 ;
17191 int val3 ;
17192 int ecode3 = 0 ;
17193 PyObject * obj0 = 0 ;
17194 PyObject * obj1 = 0 ;
17195 PyObject * obj2 = 0 ;
17196 char * kwnames[] = {
17197 (char *) "self",(char *) "row",(char *) "col", NULL
17198 };
17199
17200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17202 if (!SWIG_IsOK(res1)) {
17203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17204 }
17205 arg1 = reinterpret_cast< wxGrid * >(argp1);
17206 ecode2 = SWIG_AsVal_int(obj1, &val2);
17207 if (!SWIG_IsOK(ecode2)) {
17208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17209 }
17210 arg2 = static_cast< int >(val2);
17211 ecode3 = SWIG_AsVal_int(obj2, &val3);
17212 if (!SWIG_IsOK(ecode3)) {
17213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17214 }
17215 arg3 = static_cast< int >(val3);
17216 {
17217 PyThreadState* __tstate = wxPyBeginAllowThreads();
17218 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17219 wxPyEndAllowThreads(__tstate);
17220 if (PyErr_Occurred()) SWIG_fail;
17221 }
17222 {
17223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17224 }
17225 return resultobj;
17226 fail:
17227 return NULL;
17228 }
17229
17230
17231 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17232 PyObject *resultobj = 0;
17233 wxGrid *arg1 = (wxGrid *) 0 ;
17234 int arg2 ;
17235 int arg3 ;
17236 bool arg4 = (bool) true ;
17237 void *argp1 = 0 ;
17238 int res1 = 0 ;
17239 int val2 ;
17240 int ecode2 = 0 ;
17241 int val3 ;
17242 int ecode3 = 0 ;
17243 bool val4 ;
17244 int ecode4 = 0 ;
17245 PyObject * obj0 = 0 ;
17246 PyObject * obj1 = 0 ;
17247 PyObject * obj2 = 0 ;
17248 PyObject * obj3 = 0 ;
17249 char * kwnames[] = {
17250 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17251 };
17252
17253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17255 if (!SWIG_IsOK(res1)) {
17256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17257 }
17258 arg1 = reinterpret_cast< wxGrid * >(argp1);
17259 ecode2 = SWIG_AsVal_int(obj1, &val2);
17260 if (!SWIG_IsOK(ecode2)) {
17261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17262 }
17263 arg2 = static_cast< int >(val2);
17264 ecode3 = SWIG_AsVal_int(obj2, &val3);
17265 if (!SWIG_IsOK(ecode3)) {
17266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17267 }
17268 arg3 = static_cast< int >(val3);
17269 if (obj3) {
17270 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17271 if (!SWIG_IsOK(ecode4)) {
17272 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17273 }
17274 arg4 = static_cast< bool >(val4);
17275 }
17276 {
17277 PyThreadState* __tstate = wxPyBeginAllowThreads();
17278 (arg1)->SetReadOnly(arg2,arg3,arg4);
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 resultobj = SWIG_Py_Void();
17283 return resultobj;
17284 fail:
17285 return NULL;
17286 }
17287
17288
17289 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17290 PyObject *resultobj = 0;
17291 wxGrid *arg1 = (wxGrid *) 0 ;
17292 int arg2 ;
17293 bool arg3 = (bool) false ;
17294 void *argp1 = 0 ;
17295 int res1 = 0 ;
17296 int val2 ;
17297 int ecode2 = 0 ;
17298 bool val3 ;
17299 int ecode3 = 0 ;
17300 PyObject * obj0 = 0 ;
17301 PyObject * obj1 = 0 ;
17302 PyObject * obj2 = 0 ;
17303 char * kwnames[] = {
17304 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17305 };
17306
17307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17309 if (!SWIG_IsOK(res1)) {
17310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17311 }
17312 arg1 = reinterpret_cast< wxGrid * >(argp1);
17313 ecode2 = SWIG_AsVal_int(obj1, &val2);
17314 if (!SWIG_IsOK(ecode2)) {
17315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17316 }
17317 arg2 = static_cast< int >(val2);
17318 if (obj2) {
17319 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17320 if (!SWIG_IsOK(ecode3)) {
17321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17322 }
17323 arg3 = static_cast< bool >(val3);
17324 }
17325 {
17326 PyThreadState* __tstate = wxPyBeginAllowThreads();
17327 (arg1)->SelectRow(arg2,arg3);
17328 wxPyEndAllowThreads(__tstate);
17329 if (PyErr_Occurred()) SWIG_fail;
17330 }
17331 resultobj = SWIG_Py_Void();
17332 return resultobj;
17333 fail:
17334 return NULL;
17335 }
17336
17337
17338 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17339 PyObject *resultobj = 0;
17340 wxGrid *arg1 = (wxGrid *) 0 ;
17341 int arg2 ;
17342 bool arg3 = (bool) false ;
17343 void *argp1 = 0 ;
17344 int res1 = 0 ;
17345 int val2 ;
17346 int ecode2 = 0 ;
17347 bool val3 ;
17348 int ecode3 = 0 ;
17349 PyObject * obj0 = 0 ;
17350 PyObject * obj1 = 0 ;
17351 PyObject * obj2 = 0 ;
17352 char * kwnames[] = {
17353 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17354 };
17355
17356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17358 if (!SWIG_IsOK(res1)) {
17359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17360 }
17361 arg1 = reinterpret_cast< wxGrid * >(argp1);
17362 ecode2 = SWIG_AsVal_int(obj1, &val2);
17363 if (!SWIG_IsOK(ecode2)) {
17364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17365 }
17366 arg2 = static_cast< int >(val2);
17367 if (obj2) {
17368 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17369 if (!SWIG_IsOK(ecode3)) {
17370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17371 }
17372 arg3 = static_cast< bool >(val3);
17373 }
17374 {
17375 PyThreadState* __tstate = wxPyBeginAllowThreads();
17376 (arg1)->SelectCol(arg2,arg3);
17377 wxPyEndAllowThreads(__tstate);
17378 if (PyErr_Occurred()) SWIG_fail;
17379 }
17380 resultobj = SWIG_Py_Void();
17381 return resultobj;
17382 fail:
17383 return NULL;
17384 }
17385
17386
17387 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17388 PyObject *resultobj = 0;
17389 wxGrid *arg1 = (wxGrid *) 0 ;
17390 int arg2 ;
17391 int arg3 ;
17392 int arg4 ;
17393 int arg5 ;
17394 bool arg6 = (bool) false ;
17395 void *argp1 = 0 ;
17396 int res1 = 0 ;
17397 int val2 ;
17398 int ecode2 = 0 ;
17399 int val3 ;
17400 int ecode3 = 0 ;
17401 int val4 ;
17402 int ecode4 = 0 ;
17403 int val5 ;
17404 int ecode5 = 0 ;
17405 bool val6 ;
17406 int ecode6 = 0 ;
17407 PyObject * obj0 = 0 ;
17408 PyObject * obj1 = 0 ;
17409 PyObject * obj2 = 0 ;
17410 PyObject * obj3 = 0 ;
17411 PyObject * obj4 = 0 ;
17412 PyObject * obj5 = 0 ;
17413 char * kwnames[] = {
17414 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17415 };
17416
17417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17419 if (!SWIG_IsOK(res1)) {
17420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17421 }
17422 arg1 = reinterpret_cast< wxGrid * >(argp1);
17423 ecode2 = SWIG_AsVal_int(obj1, &val2);
17424 if (!SWIG_IsOK(ecode2)) {
17425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17426 }
17427 arg2 = static_cast< int >(val2);
17428 ecode3 = SWIG_AsVal_int(obj2, &val3);
17429 if (!SWIG_IsOK(ecode3)) {
17430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17431 }
17432 arg3 = static_cast< int >(val3);
17433 ecode4 = SWIG_AsVal_int(obj3, &val4);
17434 if (!SWIG_IsOK(ecode4)) {
17435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17436 }
17437 arg4 = static_cast< int >(val4);
17438 ecode5 = SWIG_AsVal_int(obj4, &val5);
17439 if (!SWIG_IsOK(ecode5)) {
17440 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17441 }
17442 arg5 = static_cast< int >(val5);
17443 if (obj5) {
17444 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17445 if (!SWIG_IsOK(ecode6)) {
17446 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17447 }
17448 arg6 = static_cast< bool >(val6);
17449 }
17450 {
17451 PyThreadState* __tstate = wxPyBeginAllowThreads();
17452 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17453 wxPyEndAllowThreads(__tstate);
17454 if (PyErr_Occurred()) SWIG_fail;
17455 }
17456 resultobj = SWIG_Py_Void();
17457 return resultobj;
17458 fail:
17459 return NULL;
17460 }
17461
17462
17463 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17464 PyObject *resultobj = 0;
17465 wxGrid *arg1 = (wxGrid *) 0 ;
17466 void *argp1 = 0 ;
17467 int res1 = 0 ;
17468 PyObject *swig_obj[1] ;
17469
17470 if (!args) SWIG_fail;
17471 swig_obj[0] = args;
17472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17473 if (!SWIG_IsOK(res1)) {
17474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17475 }
17476 arg1 = reinterpret_cast< wxGrid * >(argp1);
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 (arg1)->SelectAll();
17480 wxPyEndAllowThreads(__tstate);
17481 if (PyErr_Occurred()) SWIG_fail;
17482 }
17483 resultobj = SWIG_Py_Void();
17484 return resultobj;
17485 fail:
17486 return NULL;
17487 }
17488
17489
17490 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491 PyObject *resultobj = 0;
17492 wxGrid *arg1 = (wxGrid *) 0 ;
17493 bool result;
17494 void *argp1 = 0 ;
17495 int res1 = 0 ;
17496 PyObject *swig_obj[1] ;
17497
17498 if (!args) SWIG_fail;
17499 swig_obj[0] = args;
17500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17501 if (!SWIG_IsOK(res1)) {
17502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17503 }
17504 arg1 = reinterpret_cast< wxGrid * >(argp1);
17505 {
17506 PyThreadState* __tstate = wxPyBeginAllowThreads();
17507 result = (bool)(arg1)->IsSelection();
17508 wxPyEndAllowThreads(__tstate);
17509 if (PyErr_Occurred()) SWIG_fail;
17510 }
17511 {
17512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17513 }
17514 return resultobj;
17515 fail:
17516 return NULL;
17517 }
17518
17519
17520 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17521 PyObject *resultobj = 0;
17522 wxGrid *arg1 = (wxGrid *) 0 ;
17523 void *argp1 = 0 ;
17524 int res1 = 0 ;
17525 PyObject *swig_obj[1] ;
17526
17527 if (!args) SWIG_fail;
17528 swig_obj[0] = args;
17529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17530 if (!SWIG_IsOK(res1)) {
17531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17532 }
17533 arg1 = reinterpret_cast< wxGrid * >(argp1);
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 (arg1)->ClearSelection();
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 resultobj = SWIG_Py_Void();
17541 return resultobj;
17542 fail:
17543 return NULL;
17544 }
17545
17546
17547 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17548 PyObject *resultobj = 0;
17549 wxGrid *arg1 = (wxGrid *) 0 ;
17550 int arg2 ;
17551 int arg3 ;
17552 bool result;
17553 void *argp1 = 0 ;
17554 int res1 = 0 ;
17555 int val2 ;
17556 int ecode2 = 0 ;
17557 int val3 ;
17558 int ecode3 = 0 ;
17559 PyObject * obj0 = 0 ;
17560 PyObject * obj1 = 0 ;
17561 PyObject * obj2 = 0 ;
17562 char * kwnames[] = {
17563 (char *) "self",(char *) "row",(char *) "col", NULL
17564 };
17565
17566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17568 if (!SWIG_IsOK(res1)) {
17569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17570 }
17571 arg1 = reinterpret_cast< wxGrid * >(argp1);
17572 ecode2 = SWIG_AsVal_int(obj1, &val2);
17573 if (!SWIG_IsOK(ecode2)) {
17574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17575 }
17576 arg2 = static_cast< int >(val2);
17577 ecode3 = SWIG_AsVal_int(obj2, &val3);
17578 if (!SWIG_IsOK(ecode3)) {
17579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17580 }
17581 arg3 = static_cast< int >(val3);
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17590 }
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17598 PyObject *resultobj = 0;
17599 wxGrid *arg1 = (wxGrid *) 0 ;
17600 wxGridCellCoordsArray result;
17601 void *argp1 = 0 ;
17602 int res1 = 0 ;
17603 PyObject *swig_obj[1] ;
17604
17605 if (!args) SWIG_fail;
17606 swig_obj[0] = args;
17607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17608 if (!SWIG_IsOK(res1)) {
17609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17610 }
17611 arg1 = reinterpret_cast< wxGrid * >(argp1);
17612 {
17613 PyThreadState* __tstate = wxPyBeginAllowThreads();
17614 result = ((wxGrid const *)arg1)->GetSelectedCells();
17615 wxPyEndAllowThreads(__tstate);
17616 if (PyErr_Occurred()) SWIG_fail;
17617 }
17618 {
17619 resultobj = wxGridCellCoordsArray_helper(result);
17620 }
17621 return resultobj;
17622 fail:
17623 return NULL;
17624 }
17625
17626
17627 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17628 PyObject *resultobj = 0;
17629 wxGrid *arg1 = (wxGrid *) 0 ;
17630 wxGridCellCoordsArray result;
17631 void *argp1 = 0 ;
17632 int res1 = 0 ;
17633 PyObject *swig_obj[1] ;
17634
17635 if (!args) SWIG_fail;
17636 swig_obj[0] = args;
17637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17638 if (!SWIG_IsOK(res1)) {
17639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17640 }
17641 arg1 = reinterpret_cast< wxGrid * >(argp1);
17642 {
17643 PyThreadState* __tstate = wxPyBeginAllowThreads();
17644 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17645 wxPyEndAllowThreads(__tstate);
17646 if (PyErr_Occurred()) SWIG_fail;
17647 }
17648 {
17649 resultobj = wxGridCellCoordsArray_helper(result);
17650 }
17651 return resultobj;
17652 fail:
17653 return NULL;
17654 }
17655
17656
17657 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17658 PyObject *resultobj = 0;
17659 wxGrid *arg1 = (wxGrid *) 0 ;
17660 wxGridCellCoordsArray result;
17661 void *argp1 = 0 ;
17662 int res1 = 0 ;
17663 PyObject *swig_obj[1] ;
17664
17665 if (!args) SWIG_fail;
17666 swig_obj[0] = args;
17667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17668 if (!SWIG_IsOK(res1)) {
17669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17670 }
17671 arg1 = reinterpret_cast< wxGrid * >(argp1);
17672 {
17673 PyThreadState* __tstate = wxPyBeginAllowThreads();
17674 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17675 wxPyEndAllowThreads(__tstate);
17676 if (PyErr_Occurred()) SWIG_fail;
17677 }
17678 {
17679 resultobj = wxGridCellCoordsArray_helper(result);
17680 }
17681 return resultobj;
17682 fail:
17683 return NULL;
17684 }
17685
17686
17687 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17688 PyObject *resultobj = 0;
17689 wxGrid *arg1 = (wxGrid *) 0 ;
17690 wxArrayInt result;
17691 void *argp1 = 0 ;
17692 int res1 = 0 ;
17693 PyObject *swig_obj[1] ;
17694
17695 if (!args) SWIG_fail;
17696 swig_obj[0] = args;
17697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17698 if (!SWIG_IsOK(res1)) {
17699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17700 }
17701 arg1 = reinterpret_cast< wxGrid * >(argp1);
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = ((wxGrid const *)arg1)->GetSelectedRows();
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 {
17709 resultobj = PyList_New(0);
17710 size_t idx;
17711 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17712 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17713 PyList_Append(resultobj, val);
17714 Py_DECREF(val);
17715 }
17716 }
17717 return resultobj;
17718 fail:
17719 return NULL;
17720 }
17721
17722
17723 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17724 PyObject *resultobj = 0;
17725 wxGrid *arg1 = (wxGrid *) 0 ;
17726 wxArrayInt result;
17727 void *argp1 = 0 ;
17728 int res1 = 0 ;
17729 PyObject *swig_obj[1] ;
17730
17731 if (!args) SWIG_fail;
17732 swig_obj[0] = args;
17733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17734 if (!SWIG_IsOK(res1)) {
17735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17736 }
17737 arg1 = reinterpret_cast< wxGrid * >(argp1);
17738 {
17739 PyThreadState* __tstate = wxPyBeginAllowThreads();
17740 result = ((wxGrid const *)arg1)->GetSelectedCols();
17741 wxPyEndAllowThreads(__tstate);
17742 if (PyErr_Occurred()) SWIG_fail;
17743 }
17744 {
17745 resultobj = PyList_New(0);
17746 size_t idx;
17747 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17748 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17749 PyList_Append(resultobj, val);
17750 Py_DECREF(val);
17751 }
17752 }
17753 return resultobj;
17754 fail:
17755 return NULL;
17756 }
17757
17758
17759 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj = 0;
17761 wxGrid *arg1 = (wxGrid *) 0 ;
17762 int arg2 ;
17763 void *argp1 = 0 ;
17764 int res1 = 0 ;
17765 int val2 ;
17766 int ecode2 = 0 ;
17767 PyObject * obj0 = 0 ;
17768 PyObject * obj1 = 0 ;
17769 char * kwnames[] = {
17770 (char *) "self",(char *) "row", NULL
17771 };
17772
17773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17775 if (!SWIG_IsOK(res1)) {
17776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17777 }
17778 arg1 = reinterpret_cast< wxGrid * >(argp1);
17779 ecode2 = SWIG_AsVal_int(obj1, &val2);
17780 if (!SWIG_IsOK(ecode2)) {
17781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17782 }
17783 arg2 = static_cast< int >(val2);
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 (arg1)->DeselectRow(arg2);
17787 wxPyEndAllowThreads(__tstate);
17788 if (PyErr_Occurred()) SWIG_fail;
17789 }
17790 resultobj = SWIG_Py_Void();
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17798 PyObject *resultobj = 0;
17799 wxGrid *arg1 = (wxGrid *) 0 ;
17800 int arg2 ;
17801 void *argp1 = 0 ;
17802 int res1 = 0 ;
17803 int val2 ;
17804 int ecode2 = 0 ;
17805 PyObject * obj0 = 0 ;
17806 PyObject * obj1 = 0 ;
17807 char * kwnames[] = {
17808 (char *) "self",(char *) "col", NULL
17809 };
17810
17811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17813 if (!SWIG_IsOK(res1)) {
17814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17815 }
17816 arg1 = reinterpret_cast< wxGrid * >(argp1);
17817 ecode2 = SWIG_AsVal_int(obj1, &val2);
17818 if (!SWIG_IsOK(ecode2)) {
17819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17820 }
17821 arg2 = static_cast< int >(val2);
17822 {
17823 PyThreadState* __tstate = wxPyBeginAllowThreads();
17824 (arg1)->DeselectCol(arg2);
17825 wxPyEndAllowThreads(__tstate);
17826 if (PyErr_Occurred()) SWIG_fail;
17827 }
17828 resultobj = SWIG_Py_Void();
17829 return resultobj;
17830 fail:
17831 return NULL;
17832 }
17833
17834
17835 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj = 0;
17837 wxGrid *arg1 = (wxGrid *) 0 ;
17838 int arg2 ;
17839 int arg3 ;
17840 void *argp1 = 0 ;
17841 int res1 = 0 ;
17842 int val2 ;
17843 int ecode2 = 0 ;
17844 int val3 ;
17845 int ecode3 = 0 ;
17846 PyObject * obj0 = 0 ;
17847 PyObject * obj1 = 0 ;
17848 PyObject * obj2 = 0 ;
17849 char * kwnames[] = {
17850 (char *) "self",(char *) "row",(char *) "col", NULL
17851 };
17852
17853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17855 if (!SWIG_IsOK(res1)) {
17856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17857 }
17858 arg1 = reinterpret_cast< wxGrid * >(argp1);
17859 ecode2 = SWIG_AsVal_int(obj1, &val2);
17860 if (!SWIG_IsOK(ecode2)) {
17861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17862 }
17863 arg2 = static_cast< int >(val2);
17864 ecode3 = SWIG_AsVal_int(obj2, &val3);
17865 if (!SWIG_IsOK(ecode3)) {
17866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17867 }
17868 arg3 = static_cast< int >(val3);
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 (arg1)->DeselectCell(arg2,arg3);
17872 wxPyEndAllowThreads(__tstate);
17873 if (PyErr_Occurred()) SWIG_fail;
17874 }
17875 resultobj = SWIG_Py_Void();
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17883 PyObject *resultobj = 0;
17884 wxGrid *arg1 = (wxGrid *) 0 ;
17885 wxGridCellCoords *arg2 = 0 ;
17886 wxGridCellCoords *arg3 = 0 ;
17887 wxRect result;
17888 void *argp1 = 0 ;
17889 int res1 = 0 ;
17890 wxGridCellCoords temp2 ;
17891 wxGridCellCoords temp3 ;
17892 PyObject * obj0 = 0 ;
17893 PyObject * obj1 = 0 ;
17894 PyObject * obj2 = 0 ;
17895 char * kwnames[] = {
17896 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
17897 };
17898
17899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17901 if (!SWIG_IsOK(res1)) {
17902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
17903 }
17904 arg1 = reinterpret_cast< wxGrid * >(argp1);
17905 {
17906 arg2 = &temp2;
17907 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
17908 }
17909 {
17910 arg3 = &temp3;
17911 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
17912 }
17913 {
17914 PyThreadState* __tstate = wxPyBeginAllowThreads();
17915 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
17916 wxPyEndAllowThreads(__tstate);
17917 if (PyErr_Occurred()) SWIG_fail;
17918 }
17919 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17920 return resultobj;
17921 fail:
17922 return NULL;
17923 }
17924
17925
17926 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17927 PyObject *resultobj = 0;
17928 wxGrid *arg1 = (wxGrid *) 0 ;
17929 wxColour result;
17930 void *argp1 = 0 ;
17931 int res1 = 0 ;
17932 PyObject *swig_obj[1] ;
17933
17934 if (!args) SWIG_fail;
17935 swig_obj[0] = args;
17936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17937 if (!SWIG_IsOK(res1)) {
17938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17939 }
17940 arg1 = reinterpret_cast< wxGrid * >(argp1);
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = ((wxGrid const *)arg1)->GetSelectionBackground();
17944 wxPyEndAllowThreads(__tstate);
17945 if (PyErr_Occurred()) SWIG_fail;
17946 }
17947 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17948 return resultobj;
17949 fail:
17950 return NULL;
17951 }
17952
17953
17954 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17955 PyObject *resultobj = 0;
17956 wxGrid *arg1 = (wxGrid *) 0 ;
17957 wxColour result;
17958 void *argp1 = 0 ;
17959 int res1 = 0 ;
17960 PyObject *swig_obj[1] ;
17961
17962 if (!args) SWIG_fail;
17963 swig_obj[0] = args;
17964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17965 if (!SWIG_IsOK(res1)) {
17966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17967 }
17968 arg1 = reinterpret_cast< wxGrid * >(argp1);
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 result = ((wxGrid const *)arg1)->GetSelectionForeground();
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj = 0;
17984 wxGrid *arg1 = (wxGrid *) 0 ;
17985 wxColour *arg2 = 0 ;
17986 void *argp1 = 0 ;
17987 int res1 = 0 ;
17988 wxColour temp2 ;
17989 PyObject * obj0 = 0 ;
17990 PyObject * obj1 = 0 ;
17991 char * kwnames[] = {
17992 (char *) "self",(char *) "c", NULL
17993 };
17994
17995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
17996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17997 if (!SWIG_IsOK(res1)) {
17998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
17999 }
18000 arg1 = reinterpret_cast< wxGrid * >(argp1);
18001 {
18002 arg2 = &temp2;
18003 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18004 }
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 resultobj = SWIG_Py_Void();
18012 return resultobj;
18013 fail:
18014 return NULL;
18015 }
18016
18017
18018 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18019 PyObject *resultobj = 0;
18020 wxGrid *arg1 = (wxGrid *) 0 ;
18021 wxColour *arg2 = 0 ;
18022 void *argp1 = 0 ;
18023 int res1 = 0 ;
18024 wxColour temp2 ;
18025 PyObject * obj0 = 0 ;
18026 PyObject * obj1 = 0 ;
18027 char * kwnames[] = {
18028 (char *) "self",(char *) "c", NULL
18029 };
18030
18031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18033 if (!SWIG_IsOK(res1)) {
18034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18035 }
18036 arg1 = reinterpret_cast< wxGrid * >(argp1);
18037 {
18038 arg2 = &temp2;
18039 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18040 }
18041 {
18042 PyThreadState* __tstate = wxPyBeginAllowThreads();
18043 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18044 wxPyEndAllowThreads(__tstate);
18045 if (PyErr_Occurred()) SWIG_fail;
18046 }
18047 resultobj = SWIG_Py_Void();
18048 return resultobj;
18049 fail:
18050 return NULL;
18051 }
18052
18053
18054 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18055 PyObject *resultobj = 0;
18056 wxGrid *arg1 = (wxGrid *) 0 ;
18057 wxString *arg2 = 0 ;
18058 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18059 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18060 void *argp1 = 0 ;
18061 int res1 = 0 ;
18062 bool temp2 = false ;
18063 void *argp3 = 0 ;
18064 int res3 = 0 ;
18065 void *argp4 = 0 ;
18066 int res4 = 0 ;
18067 PyObject * obj0 = 0 ;
18068 PyObject * obj1 = 0 ;
18069 PyObject * obj2 = 0 ;
18070 PyObject * obj3 = 0 ;
18071 char * kwnames[] = {
18072 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18073 };
18074
18075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18077 if (!SWIG_IsOK(res1)) {
18078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18079 }
18080 arg1 = reinterpret_cast< wxGrid * >(argp1);
18081 {
18082 arg2 = wxString_in_helper(obj1);
18083 if (arg2 == NULL) SWIG_fail;
18084 temp2 = true;
18085 }
18086 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18087 if (!SWIG_IsOK(res3)) {
18088 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18089 }
18090 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18091 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18092 if (!SWIG_IsOK(res4)) {
18093 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18094 }
18095 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18096 {
18097 PyThreadState* __tstate = wxPyBeginAllowThreads();
18098 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18099 wxPyEndAllowThreads(__tstate);
18100 if (PyErr_Occurred()) SWIG_fail;
18101 }
18102 resultobj = SWIG_Py_Void();
18103 {
18104 if (temp2)
18105 delete arg2;
18106 }
18107 return resultobj;
18108 fail:
18109 {
18110 if (temp2)
18111 delete arg2;
18112 }
18113 return NULL;
18114 }
18115
18116
18117 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18118 PyObject *resultobj = 0;
18119 wxGrid *arg1 = (wxGrid *) 0 ;
18120 int arg2 ;
18121 int arg3 ;
18122 wxGridCellEditor *result = 0 ;
18123 void *argp1 = 0 ;
18124 int res1 = 0 ;
18125 int val2 ;
18126 int ecode2 = 0 ;
18127 int val3 ;
18128 int ecode3 = 0 ;
18129 PyObject * obj0 = 0 ;
18130 PyObject * obj1 = 0 ;
18131 PyObject * obj2 = 0 ;
18132 char * kwnames[] = {
18133 (char *) "self",(char *) "row",(char *) "col", NULL
18134 };
18135
18136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18138 if (!SWIG_IsOK(res1)) {
18139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18140 }
18141 arg1 = reinterpret_cast< wxGrid * >(argp1);
18142 ecode2 = SWIG_AsVal_int(obj1, &val2);
18143 if (!SWIG_IsOK(ecode2)) {
18144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18145 }
18146 arg2 = static_cast< int >(val2);
18147 ecode3 = SWIG_AsVal_int(obj2, &val3);
18148 if (!SWIG_IsOK(ecode3)) {
18149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18150 }
18151 arg3 = static_cast< int >(val3);
18152 {
18153 PyThreadState* __tstate = wxPyBeginAllowThreads();
18154 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18155 wxPyEndAllowThreads(__tstate);
18156 if (PyErr_Occurred()) SWIG_fail;
18157 }
18158 {
18159 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18160 }
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18168 PyObject *resultobj = 0;
18169 wxGrid *arg1 = (wxGrid *) 0 ;
18170 int arg2 ;
18171 int arg3 ;
18172 wxGridCellRenderer *result = 0 ;
18173 void *argp1 = 0 ;
18174 int res1 = 0 ;
18175 int val2 ;
18176 int ecode2 = 0 ;
18177 int val3 ;
18178 int ecode3 = 0 ;
18179 PyObject * obj0 = 0 ;
18180 PyObject * obj1 = 0 ;
18181 PyObject * obj2 = 0 ;
18182 char * kwnames[] = {
18183 (char *) "self",(char *) "row",(char *) "col", NULL
18184 };
18185
18186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18188 if (!SWIG_IsOK(res1)) {
18189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18190 }
18191 arg1 = reinterpret_cast< wxGrid * >(argp1);
18192 ecode2 = SWIG_AsVal_int(obj1, &val2);
18193 if (!SWIG_IsOK(ecode2)) {
18194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18195 }
18196 arg2 = static_cast< int >(val2);
18197 ecode3 = SWIG_AsVal_int(obj2, &val3);
18198 if (!SWIG_IsOK(ecode3)) {
18199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18200 }
18201 arg3 = static_cast< int >(val3);
18202 {
18203 PyThreadState* __tstate = wxPyBeginAllowThreads();
18204 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18205 wxPyEndAllowThreads(__tstate);
18206 if (PyErr_Occurred()) SWIG_fail;
18207 }
18208 {
18209 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18210 }
18211 return resultobj;
18212 fail:
18213 return NULL;
18214 }
18215
18216
18217 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18218 PyObject *resultobj = 0;
18219 wxGrid *arg1 = (wxGrid *) 0 ;
18220 wxString *arg2 = 0 ;
18221 wxGridCellEditor *result = 0 ;
18222 void *argp1 = 0 ;
18223 int res1 = 0 ;
18224 bool temp2 = false ;
18225 PyObject * obj0 = 0 ;
18226 PyObject * obj1 = 0 ;
18227 char * kwnames[] = {
18228 (char *) "self",(char *) "typeName", NULL
18229 };
18230
18231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18233 if (!SWIG_IsOK(res1)) {
18234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18235 }
18236 arg1 = reinterpret_cast< wxGrid * >(argp1);
18237 {
18238 arg2 = wxString_in_helper(obj1);
18239 if (arg2 == NULL) SWIG_fail;
18240 temp2 = true;
18241 }
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18245 wxPyEndAllowThreads(__tstate);
18246 if (PyErr_Occurred()) SWIG_fail;
18247 }
18248 {
18249 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18250 }
18251 {
18252 if (temp2)
18253 delete arg2;
18254 }
18255 return resultobj;
18256 fail:
18257 {
18258 if (temp2)
18259 delete arg2;
18260 }
18261 return NULL;
18262 }
18263
18264
18265 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj = 0;
18267 wxGrid *arg1 = (wxGrid *) 0 ;
18268 wxString *arg2 = 0 ;
18269 wxGridCellRenderer *result = 0 ;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 bool temp2 = false ;
18273 PyObject * obj0 = 0 ;
18274 PyObject * obj1 = 0 ;
18275 char * kwnames[] = {
18276 (char *) "self",(char *) "typeName", NULL
18277 };
18278
18279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18281 if (!SWIG_IsOK(res1)) {
18282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18283 }
18284 arg1 = reinterpret_cast< wxGrid * >(argp1);
18285 {
18286 arg2 = wxString_in_helper(obj1);
18287 if (arg2 == NULL) SWIG_fail;
18288 temp2 = true;
18289 }
18290 {
18291 PyThreadState* __tstate = wxPyBeginAllowThreads();
18292 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 {
18297 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18298 }
18299 {
18300 if (temp2)
18301 delete arg2;
18302 }
18303 return resultobj;
18304 fail:
18305 {
18306 if (temp2)
18307 delete arg2;
18308 }
18309 return NULL;
18310 }
18311
18312
18313 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18314 PyObject *resultobj = 0;
18315 wxGrid *arg1 = (wxGrid *) 0 ;
18316 int arg2 ;
18317 int arg3 ;
18318 void *argp1 = 0 ;
18319 int res1 = 0 ;
18320 int val2 ;
18321 int ecode2 = 0 ;
18322 int val3 ;
18323 int ecode3 = 0 ;
18324 PyObject * obj0 = 0 ;
18325 PyObject * obj1 = 0 ;
18326 PyObject * obj2 = 0 ;
18327 char * kwnames[] = {
18328 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18329 };
18330
18331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18333 if (!SWIG_IsOK(res1)) {
18334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18335 }
18336 arg1 = reinterpret_cast< wxGrid * >(argp1);
18337 ecode2 = SWIG_AsVal_int(obj1, &val2);
18338 if (!SWIG_IsOK(ecode2)) {
18339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18340 }
18341 arg2 = static_cast< int >(val2);
18342 ecode3 = SWIG_AsVal_int(obj2, &val3);
18343 if (!SWIG_IsOK(ecode3)) {
18344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18345 }
18346 arg3 = static_cast< int >(val3);
18347 {
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 (arg1)->SetMargins(arg2,arg3);
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = SWIG_Py_Void();
18354 return resultobj;
18355 fail:
18356 return NULL;
18357 }
18358
18359
18360 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18361 PyObject *resultobj = 0;
18362 wxGrid *arg1 = (wxGrid *) 0 ;
18363 wxWindow *result = 0 ;
18364 void *argp1 = 0 ;
18365 int res1 = 0 ;
18366 PyObject *swig_obj[1] ;
18367
18368 if (!args) SWIG_fail;
18369 swig_obj[0] = args;
18370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18371 if (!SWIG_IsOK(res1)) {
18372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18373 }
18374 arg1 = reinterpret_cast< wxGrid * >(argp1);
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 result = (wxWindow *)(arg1)->GetGridWindow();
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = wxPyMake_wxObject(result, 0);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18391 PyObject *resultobj = 0;
18392 wxGrid *arg1 = (wxGrid *) 0 ;
18393 wxWindow *result = 0 ;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 PyObject *swig_obj[1] ;
18397
18398 if (!args) SWIG_fail;
18399 swig_obj[0] = args;
18400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18401 if (!SWIG_IsOK(res1)) {
18402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18403 }
18404 arg1 = reinterpret_cast< wxGrid * >(argp1);
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 {
18412 resultobj = wxPyMake_wxObject(result, 0);
18413 }
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18421 PyObject *resultobj = 0;
18422 wxGrid *arg1 = (wxGrid *) 0 ;
18423 wxWindow *result = 0 ;
18424 void *argp1 = 0 ;
18425 int res1 = 0 ;
18426 PyObject *swig_obj[1] ;
18427
18428 if (!args) SWIG_fail;
18429 swig_obj[0] = args;
18430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18431 if (!SWIG_IsOK(res1)) {
18432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18433 }
18434 arg1 = reinterpret_cast< wxGrid * >(argp1);
18435 {
18436 PyThreadState* __tstate = wxPyBeginAllowThreads();
18437 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18438 wxPyEndAllowThreads(__tstate);
18439 if (PyErr_Occurred()) SWIG_fail;
18440 }
18441 {
18442 resultobj = wxPyMake_wxObject(result, 0);
18443 }
18444 return resultobj;
18445 fail:
18446 return NULL;
18447 }
18448
18449
18450 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18451 PyObject *resultobj = 0;
18452 wxGrid *arg1 = (wxGrid *) 0 ;
18453 wxWindow *result = 0 ;
18454 void *argp1 = 0 ;
18455 int res1 = 0 ;
18456 PyObject *swig_obj[1] ;
18457
18458 if (!args) SWIG_fail;
18459 swig_obj[0] = args;
18460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18461 if (!SWIG_IsOK(res1)) {
18462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18463 }
18464 arg1 = reinterpret_cast< wxGrid * >(argp1);
18465 {
18466 PyThreadState* __tstate = wxPyBeginAllowThreads();
18467 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18468 wxPyEndAllowThreads(__tstate);
18469 if (PyErr_Occurred()) SWIG_fail;
18470 }
18471 {
18472 resultobj = wxPyMake_wxObject(result, 0);
18473 }
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj = 0;
18482 wxGrid *arg1 = (wxGrid *) 0 ;
18483 int arg2 ;
18484 void *argp1 = 0 ;
18485 int res1 = 0 ;
18486 int val2 ;
18487 int ecode2 = 0 ;
18488 PyObject * obj0 = 0 ;
18489 PyObject * obj1 = 0 ;
18490 char * kwnames[] = {
18491 (char *) "self",(char *) "x", NULL
18492 };
18493
18494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18496 if (!SWIG_IsOK(res1)) {
18497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18498 }
18499 arg1 = reinterpret_cast< wxGrid * >(argp1);
18500 ecode2 = SWIG_AsVal_int(obj1, &val2);
18501 if (!SWIG_IsOK(ecode2)) {
18502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18503 }
18504 arg2 = static_cast< int >(val2);
18505 {
18506 PyThreadState* __tstate = wxPyBeginAllowThreads();
18507 (arg1)->SetScrollLineX(arg2);
18508 wxPyEndAllowThreads(__tstate);
18509 if (PyErr_Occurred()) SWIG_fail;
18510 }
18511 resultobj = SWIG_Py_Void();
18512 return resultobj;
18513 fail:
18514 return NULL;
18515 }
18516
18517
18518 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18519 PyObject *resultobj = 0;
18520 wxGrid *arg1 = (wxGrid *) 0 ;
18521 int arg2 ;
18522 void *argp1 = 0 ;
18523 int res1 = 0 ;
18524 int val2 ;
18525 int ecode2 = 0 ;
18526 PyObject * obj0 = 0 ;
18527 PyObject * obj1 = 0 ;
18528 char * kwnames[] = {
18529 (char *) "self",(char *) "y", NULL
18530 };
18531
18532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18534 if (!SWIG_IsOK(res1)) {
18535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18536 }
18537 arg1 = reinterpret_cast< wxGrid * >(argp1);
18538 ecode2 = SWIG_AsVal_int(obj1, &val2);
18539 if (!SWIG_IsOK(ecode2)) {
18540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18541 }
18542 arg2 = static_cast< int >(val2);
18543 {
18544 PyThreadState* __tstate = wxPyBeginAllowThreads();
18545 (arg1)->SetScrollLineY(arg2);
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 resultobj = SWIG_Py_Void();
18550 return resultobj;
18551 fail:
18552 return NULL;
18553 }
18554
18555
18556 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18557 PyObject *resultobj = 0;
18558 wxGrid *arg1 = (wxGrid *) 0 ;
18559 int result;
18560 void *argp1 = 0 ;
18561 int res1 = 0 ;
18562 PyObject *swig_obj[1] ;
18563
18564 if (!args) SWIG_fail;
18565 swig_obj[0] = args;
18566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18567 if (!SWIG_IsOK(res1)) {
18568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18569 }
18570 arg1 = reinterpret_cast< wxGrid * >(argp1);
18571 {
18572 PyThreadState* __tstate = wxPyBeginAllowThreads();
18573 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18574 wxPyEndAllowThreads(__tstate);
18575 if (PyErr_Occurred()) SWIG_fail;
18576 }
18577 resultobj = SWIG_From_int(static_cast< int >(result));
18578 return resultobj;
18579 fail:
18580 return NULL;
18581 }
18582
18583
18584 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18585 PyObject *resultobj = 0;
18586 wxGrid *arg1 = (wxGrid *) 0 ;
18587 int result;
18588 void *argp1 = 0 ;
18589 int res1 = 0 ;
18590 PyObject *swig_obj[1] ;
18591
18592 if (!args) SWIG_fail;
18593 swig_obj[0] = args;
18594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18595 if (!SWIG_IsOK(res1)) {
18596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18597 }
18598 arg1 = reinterpret_cast< wxGrid * >(argp1);
18599 {
18600 PyThreadState* __tstate = wxPyBeginAllowThreads();
18601 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18602 wxPyEndAllowThreads(__tstate);
18603 if (PyErr_Occurred()) SWIG_fail;
18604 }
18605 resultobj = SWIG_From_int(static_cast< int >(result));
18606 return resultobj;
18607 fail:
18608 return NULL;
18609 }
18610
18611
18612 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18613 PyObject *resultobj = 0;
18614 wxGrid *arg1 = (wxGrid *) 0 ;
18615 int arg2 ;
18616 int result;
18617 void *argp1 = 0 ;
18618 int res1 = 0 ;
18619 int val2 ;
18620 int ecode2 = 0 ;
18621 PyObject * obj0 = 0 ;
18622 PyObject * obj1 = 0 ;
18623 char * kwnames[] = {
18624 (char *) "self",(char *) "x", NULL
18625 };
18626
18627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18629 if (!SWIG_IsOK(res1)) {
18630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18631 }
18632 arg1 = reinterpret_cast< wxGrid * >(argp1);
18633 ecode2 = SWIG_AsVal_int(obj1, &val2);
18634 if (!SWIG_IsOK(ecode2)) {
18635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18636 }
18637 arg2 = static_cast< int >(val2);
18638 {
18639 PyThreadState* __tstate = wxPyBeginAllowThreads();
18640 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18641 wxPyEndAllowThreads(__tstate);
18642 if (PyErr_Occurred()) SWIG_fail;
18643 }
18644 resultobj = SWIG_From_int(static_cast< int >(result));
18645 return resultobj;
18646 fail:
18647 return NULL;
18648 }
18649
18650
18651 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18652 PyObject *resultobj = 0;
18653 wxGrid *arg1 = (wxGrid *) 0 ;
18654 int arg2 ;
18655 int result;
18656 void *argp1 = 0 ;
18657 int res1 = 0 ;
18658 int val2 ;
18659 int ecode2 = 0 ;
18660 PyObject * obj0 = 0 ;
18661 PyObject * obj1 = 0 ;
18662 char * kwnames[] = {
18663 (char *) "self",(char *) "y", NULL
18664 };
18665
18666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18668 if (!SWIG_IsOK(res1)) {
18669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18670 }
18671 arg1 = reinterpret_cast< wxGrid * >(argp1);
18672 ecode2 = SWIG_AsVal_int(obj1, &val2);
18673 if (!SWIG_IsOK(ecode2)) {
18674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18675 }
18676 arg2 = static_cast< int >(val2);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18680 wxPyEndAllowThreads(__tstate);
18681 if (PyErr_Occurred()) SWIG_fail;
18682 }
18683 resultobj = SWIG_From_int(static_cast< int >(result));
18684 return resultobj;
18685 fail:
18686 return NULL;
18687 }
18688
18689
18690 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18691 PyObject *resultobj = 0;
18692 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18693 SwigValueWrapper<wxVisualAttributes > result;
18694 int val1 ;
18695 int ecode1 = 0 ;
18696 PyObject * obj0 = 0 ;
18697 char * kwnames[] = {
18698 (char *) "variant", NULL
18699 };
18700
18701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18702 if (obj0) {
18703 ecode1 = SWIG_AsVal_int(obj0, &val1);
18704 if (!SWIG_IsOK(ecode1)) {
18705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18706 }
18707 arg1 = static_cast< wxWindowVariant >(val1);
18708 }
18709 {
18710 if (!wxPyCheckForApp()) SWIG_fail;
18711 PyThreadState* __tstate = wxPyBeginAllowThreads();
18712 result = wxGrid::GetClassDefaultAttributes(arg1);
18713 wxPyEndAllowThreads(__tstate);
18714 if (PyErr_Occurred()) SWIG_fail;
18715 }
18716 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18724 PyObject *obj;
18725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18726 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18727 return SWIG_Py_Void();
18728 }
18729
18730 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18731 return SWIG_Python_InitShadowInstance(args);
18732 }
18733
18734 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18735 PyObject *resultobj = 0;
18736 int arg1 ;
18737 wxEventType arg2 ;
18738 wxGrid *arg3 = (wxGrid *) 0 ;
18739 int arg4 = (int) -1 ;
18740 int arg5 = (int) -1 ;
18741 int arg6 = (int) -1 ;
18742 int arg7 = (int) -1 ;
18743 bool arg8 = (bool) true ;
18744 bool arg9 = (bool) false ;
18745 bool arg10 = (bool) false ;
18746 bool arg11 = (bool) false ;
18747 bool arg12 = (bool) false ;
18748 wxGridEvent *result = 0 ;
18749 int val1 ;
18750 int ecode1 = 0 ;
18751 int val2 ;
18752 int ecode2 = 0 ;
18753 void *argp3 = 0 ;
18754 int res3 = 0 ;
18755 int val4 ;
18756 int ecode4 = 0 ;
18757 int val5 ;
18758 int ecode5 = 0 ;
18759 int val6 ;
18760 int ecode6 = 0 ;
18761 int val7 ;
18762 int ecode7 = 0 ;
18763 bool val8 ;
18764 int ecode8 = 0 ;
18765 bool val9 ;
18766 int ecode9 = 0 ;
18767 bool val10 ;
18768 int ecode10 = 0 ;
18769 bool val11 ;
18770 int ecode11 = 0 ;
18771 bool val12 ;
18772 int ecode12 = 0 ;
18773 PyObject * obj0 = 0 ;
18774 PyObject * obj1 = 0 ;
18775 PyObject * obj2 = 0 ;
18776 PyObject * obj3 = 0 ;
18777 PyObject * obj4 = 0 ;
18778 PyObject * obj5 = 0 ;
18779 PyObject * obj6 = 0 ;
18780 PyObject * obj7 = 0 ;
18781 PyObject * obj8 = 0 ;
18782 PyObject * obj9 = 0 ;
18783 PyObject * obj10 = 0 ;
18784 PyObject * obj11 = 0 ;
18785 char * kwnames[] = {
18786 (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
18787 };
18788
18789 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;
18790 ecode1 = SWIG_AsVal_int(obj0, &val1);
18791 if (!SWIG_IsOK(ecode1)) {
18792 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18793 }
18794 arg1 = static_cast< int >(val1);
18795 ecode2 = SWIG_AsVal_int(obj1, &val2);
18796 if (!SWIG_IsOK(ecode2)) {
18797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18798 }
18799 arg2 = static_cast< wxEventType >(val2);
18800 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18801 if (!SWIG_IsOK(res3)) {
18802 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18803 }
18804 arg3 = reinterpret_cast< wxGrid * >(argp3);
18805 if (obj3) {
18806 ecode4 = SWIG_AsVal_int(obj3, &val4);
18807 if (!SWIG_IsOK(ecode4)) {
18808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18809 }
18810 arg4 = static_cast< int >(val4);
18811 }
18812 if (obj4) {
18813 ecode5 = SWIG_AsVal_int(obj4, &val5);
18814 if (!SWIG_IsOK(ecode5)) {
18815 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18816 }
18817 arg5 = static_cast< int >(val5);
18818 }
18819 if (obj5) {
18820 ecode6 = SWIG_AsVal_int(obj5, &val6);
18821 if (!SWIG_IsOK(ecode6)) {
18822 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18823 }
18824 arg6 = static_cast< int >(val6);
18825 }
18826 if (obj6) {
18827 ecode7 = SWIG_AsVal_int(obj6, &val7);
18828 if (!SWIG_IsOK(ecode7)) {
18829 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18830 }
18831 arg7 = static_cast< int >(val7);
18832 }
18833 if (obj7) {
18834 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18835 if (!SWIG_IsOK(ecode8)) {
18836 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18837 }
18838 arg8 = static_cast< bool >(val8);
18839 }
18840 if (obj8) {
18841 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18842 if (!SWIG_IsOK(ecode9)) {
18843 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18844 }
18845 arg9 = static_cast< bool >(val9);
18846 }
18847 if (obj9) {
18848 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18849 if (!SWIG_IsOK(ecode10)) {
18850 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18851 }
18852 arg10 = static_cast< bool >(val10);
18853 }
18854 if (obj10) {
18855 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18856 if (!SWIG_IsOK(ecode11)) {
18857 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18858 }
18859 arg11 = static_cast< bool >(val11);
18860 }
18861 if (obj11) {
18862 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18863 if (!SWIG_IsOK(ecode12)) {
18864 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18865 }
18866 arg12 = static_cast< bool >(val12);
18867 }
18868 {
18869 PyThreadState* __tstate = wxPyBeginAllowThreads();
18870 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18871 wxPyEndAllowThreads(__tstate);
18872 if (PyErr_Occurred()) SWIG_fail;
18873 }
18874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18875 return resultobj;
18876 fail:
18877 return NULL;
18878 }
18879
18880
18881 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18882 PyObject *resultobj = 0;
18883 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18884 int result;
18885 void *argp1 = 0 ;
18886 int res1 = 0 ;
18887 PyObject *swig_obj[1] ;
18888
18889 if (!args) SWIG_fail;
18890 swig_obj[0] = args;
18891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18892 if (!SWIG_IsOK(res1)) {
18893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18894 }
18895 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18896 {
18897 PyThreadState* __tstate = wxPyBeginAllowThreads();
18898 result = (int)(arg1)->GetRow();
18899 wxPyEndAllowThreads(__tstate);
18900 if (PyErr_Occurred()) SWIG_fail;
18901 }
18902 resultobj = SWIG_From_int(static_cast< int >(result));
18903 return resultobj;
18904 fail:
18905 return NULL;
18906 }
18907
18908
18909 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18910 PyObject *resultobj = 0;
18911 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18912 int result;
18913 void *argp1 = 0 ;
18914 int res1 = 0 ;
18915 PyObject *swig_obj[1] ;
18916
18917 if (!args) SWIG_fail;
18918 swig_obj[0] = args;
18919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18920 if (!SWIG_IsOK(res1)) {
18921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18922 }
18923 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18924 {
18925 PyThreadState* __tstate = wxPyBeginAllowThreads();
18926 result = (int)(arg1)->GetCol();
18927 wxPyEndAllowThreads(__tstate);
18928 if (PyErr_Occurred()) SWIG_fail;
18929 }
18930 resultobj = SWIG_From_int(static_cast< int >(result));
18931 return resultobj;
18932 fail:
18933 return NULL;
18934 }
18935
18936
18937 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18938 PyObject *resultobj = 0;
18939 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18940 wxPoint result;
18941 void *argp1 = 0 ;
18942 int res1 = 0 ;
18943 PyObject *swig_obj[1] ;
18944
18945 if (!args) SWIG_fail;
18946 swig_obj[0] = args;
18947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18948 if (!SWIG_IsOK(res1)) {
18949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18950 }
18951 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 result = (arg1)->GetPosition();
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
18959 return resultobj;
18960 fail:
18961 return NULL;
18962 }
18963
18964
18965 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18966 PyObject *resultobj = 0;
18967 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18968 bool result;
18969 void *argp1 = 0 ;
18970 int res1 = 0 ;
18971 PyObject *swig_obj[1] ;
18972
18973 if (!args) SWIG_fail;
18974 swig_obj[0] = args;
18975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18976 if (!SWIG_IsOK(res1)) {
18977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18978 }
18979 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18980 {
18981 PyThreadState* __tstate = wxPyBeginAllowThreads();
18982 result = (bool)(arg1)->Selecting();
18983 wxPyEndAllowThreads(__tstate);
18984 if (PyErr_Occurred()) SWIG_fail;
18985 }
18986 {
18987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18988 }
18989 return resultobj;
18990 fail:
18991 return NULL;
18992 }
18993
18994
18995 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18996 PyObject *resultobj = 0;
18997 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18998 bool result;
18999 void *argp1 = 0 ;
19000 int res1 = 0 ;
19001 PyObject *swig_obj[1] ;
19002
19003 if (!args) SWIG_fail;
19004 swig_obj[0] = args;
19005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19006 if (!SWIG_IsOK(res1)) {
19007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19008 }
19009 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19010 {
19011 PyThreadState* __tstate = wxPyBeginAllowThreads();
19012 result = (bool)(arg1)->ControlDown();
19013 wxPyEndAllowThreads(__tstate);
19014 if (PyErr_Occurred()) SWIG_fail;
19015 }
19016 {
19017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19018 }
19019 return resultobj;
19020 fail:
19021 return NULL;
19022 }
19023
19024
19025 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19026 PyObject *resultobj = 0;
19027 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19028 bool result;
19029 void *argp1 = 0 ;
19030 int res1 = 0 ;
19031 PyObject *swig_obj[1] ;
19032
19033 if (!args) SWIG_fail;
19034 swig_obj[0] = args;
19035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19036 if (!SWIG_IsOK(res1)) {
19037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19038 }
19039 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19040 {
19041 PyThreadState* __tstate = wxPyBeginAllowThreads();
19042 result = (bool)(arg1)->MetaDown();
19043 wxPyEndAllowThreads(__tstate);
19044 if (PyErr_Occurred()) SWIG_fail;
19045 }
19046 {
19047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19048 }
19049 return resultobj;
19050 fail:
19051 return NULL;
19052 }
19053
19054
19055 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19056 PyObject *resultobj = 0;
19057 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19058 bool result;
19059 void *argp1 = 0 ;
19060 int res1 = 0 ;
19061 PyObject *swig_obj[1] ;
19062
19063 if (!args) SWIG_fail;
19064 swig_obj[0] = args;
19065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19066 if (!SWIG_IsOK(res1)) {
19067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19068 }
19069 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19070 {
19071 PyThreadState* __tstate = wxPyBeginAllowThreads();
19072 result = (bool)(arg1)->ShiftDown();
19073 wxPyEndAllowThreads(__tstate);
19074 if (PyErr_Occurred()) SWIG_fail;
19075 }
19076 {
19077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19078 }
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19086 PyObject *resultobj = 0;
19087 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19088 bool result;
19089 void *argp1 = 0 ;
19090 int res1 = 0 ;
19091 PyObject *swig_obj[1] ;
19092
19093 if (!args) SWIG_fail;
19094 swig_obj[0] = args;
19095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19096 if (!SWIG_IsOK(res1)) {
19097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19098 }
19099 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 result = (bool)(arg1)->AltDown();
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 {
19107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19108 }
19109 return resultobj;
19110 fail:
19111 return NULL;
19112 }
19113
19114
19115 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19116 PyObject *resultobj = 0;
19117 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19118 bool result;
19119 void *argp1 = 0 ;
19120 int res1 = 0 ;
19121 PyObject *swig_obj[1] ;
19122
19123 if (!args) SWIG_fail;
19124 swig_obj[0] = args;
19125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19126 if (!SWIG_IsOK(res1)) {
19127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19128 }
19129 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19130 {
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 result = (bool)(arg1)->CmdDown();
19133 wxPyEndAllowThreads(__tstate);
19134 if (PyErr_Occurred()) SWIG_fail;
19135 }
19136 {
19137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19138 }
19139 return resultobj;
19140 fail:
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19146 PyObject *obj;
19147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19148 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19149 return SWIG_Py_Void();
19150 }
19151
19152 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19153 return SWIG_Python_InitShadowInstance(args);
19154 }
19155
19156 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19157 PyObject *resultobj = 0;
19158 int arg1 ;
19159 wxEventType arg2 ;
19160 wxGrid *arg3 = (wxGrid *) 0 ;
19161 int arg4 = (int) -1 ;
19162 int arg5 = (int) -1 ;
19163 int arg6 = (int) -1 ;
19164 bool arg7 = (bool) false ;
19165 bool arg8 = (bool) false ;
19166 bool arg9 = (bool) false ;
19167 bool arg10 = (bool) false ;
19168 wxGridSizeEvent *result = 0 ;
19169 int val1 ;
19170 int ecode1 = 0 ;
19171 int val2 ;
19172 int ecode2 = 0 ;
19173 void *argp3 = 0 ;
19174 int res3 = 0 ;
19175 int val4 ;
19176 int ecode4 = 0 ;
19177 int val5 ;
19178 int ecode5 = 0 ;
19179 int val6 ;
19180 int ecode6 = 0 ;
19181 bool val7 ;
19182 int ecode7 = 0 ;
19183 bool val8 ;
19184 int ecode8 = 0 ;
19185 bool val9 ;
19186 int ecode9 = 0 ;
19187 bool val10 ;
19188 int ecode10 = 0 ;
19189 PyObject * obj0 = 0 ;
19190 PyObject * obj1 = 0 ;
19191 PyObject * obj2 = 0 ;
19192 PyObject * obj3 = 0 ;
19193 PyObject * obj4 = 0 ;
19194 PyObject * obj5 = 0 ;
19195 PyObject * obj6 = 0 ;
19196 PyObject * obj7 = 0 ;
19197 PyObject * obj8 = 0 ;
19198 PyObject * obj9 = 0 ;
19199 char * kwnames[] = {
19200 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19201 };
19202
19203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19204 ecode1 = SWIG_AsVal_int(obj0, &val1);
19205 if (!SWIG_IsOK(ecode1)) {
19206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19207 }
19208 arg1 = static_cast< int >(val1);
19209 ecode2 = SWIG_AsVal_int(obj1, &val2);
19210 if (!SWIG_IsOK(ecode2)) {
19211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19212 }
19213 arg2 = static_cast< wxEventType >(val2);
19214 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19215 if (!SWIG_IsOK(res3)) {
19216 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19217 }
19218 arg3 = reinterpret_cast< wxGrid * >(argp3);
19219 if (obj3) {
19220 ecode4 = SWIG_AsVal_int(obj3, &val4);
19221 if (!SWIG_IsOK(ecode4)) {
19222 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19223 }
19224 arg4 = static_cast< int >(val4);
19225 }
19226 if (obj4) {
19227 ecode5 = SWIG_AsVal_int(obj4, &val5);
19228 if (!SWIG_IsOK(ecode5)) {
19229 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19230 }
19231 arg5 = static_cast< int >(val5);
19232 }
19233 if (obj5) {
19234 ecode6 = SWIG_AsVal_int(obj5, &val6);
19235 if (!SWIG_IsOK(ecode6)) {
19236 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19237 }
19238 arg6 = static_cast< int >(val6);
19239 }
19240 if (obj6) {
19241 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19242 if (!SWIG_IsOK(ecode7)) {
19243 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19244 }
19245 arg7 = static_cast< bool >(val7);
19246 }
19247 if (obj7) {
19248 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19249 if (!SWIG_IsOK(ecode8)) {
19250 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19251 }
19252 arg8 = static_cast< bool >(val8);
19253 }
19254 if (obj8) {
19255 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19256 if (!SWIG_IsOK(ecode9)) {
19257 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19258 }
19259 arg9 = static_cast< bool >(val9);
19260 }
19261 if (obj9) {
19262 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19263 if (!SWIG_IsOK(ecode10)) {
19264 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19265 }
19266 arg10 = static_cast< bool >(val10);
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19271 wxPyEndAllowThreads(__tstate);
19272 if (PyErr_Occurred()) SWIG_fail;
19273 }
19274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19275 return resultobj;
19276 fail:
19277 return NULL;
19278 }
19279
19280
19281 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19282 PyObject *resultobj = 0;
19283 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19284 int result;
19285 void *argp1 = 0 ;
19286 int res1 = 0 ;
19287 PyObject *swig_obj[1] ;
19288
19289 if (!args) SWIG_fail;
19290 swig_obj[0] = args;
19291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19292 if (!SWIG_IsOK(res1)) {
19293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19294 }
19295 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19296 {
19297 PyThreadState* __tstate = wxPyBeginAllowThreads();
19298 result = (int)(arg1)->GetRowOrCol();
19299 wxPyEndAllowThreads(__tstate);
19300 if (PyErr_Occurred()) SWIG_fail;
19301 }
19302 resultobj = SWIG_From_int(static_cast< int >(result));
19303 return resultobj;
19304 fail:
19305 return NULL;
19306 }
19307
19308
19309 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19310 PyObject *resultobj = 0;
19311 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19312 wxPoint result;
19313 void *argp1 = 0 ;
19314 int res1 = 0 ;
19315 PyObject *swig_obj[1] ;
19316
19317 if (!args) SWIG_fail;
19318 swig_obj[0] = args;
19319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19320 if (!SWIG_IsOK(res1)) {
19321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19322 }
19323 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19324 {
19325 PyThreadState* __tstate = wxPyBeginAllowThreads();
19326 result = (arg1)->GetPosition();
19327 wxPyEndAllowThreads(__tstate);
19328 if (PyErr_Occurred()) SWIG_fail;
19329 }
19330 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19331 return resultobj;
19332 fail:
19333 return NULL;
19334 }
19335
19336
19337 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19338 PyObject *resultobj = 0;
19339 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19340 bool result;
19341 void *argp1 = 0 ;
19342 int res1 = 0 ;
19343 PyObject *swig_obj[1] ;
19344
19345 if (!args) SWIG_fail;
19346 swig_obj[0] = args;
19347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19348 if (!SWIG_IsOK(res1)) {
19349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19350 }
19351 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19352 {
19353 PyThreadState* __tstate = wxPyBeginAllowThreads();
19354 result = (bool)(arg1)->ControlDown();
19355 wxPyEndAllowThreads(__tstate);
19356 if (PyErr_Occurred()) SWIG_fail;
19357 }
19358 {
19359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19360 }
19361 return resultobj;
19362 fail:
19363 return NULL;
19364 }
19365
19366
19367 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19368 PyObject *resultobj = 0;
19369 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19370 bool result;
19371 void *argp1 = 0 ;
19372 int res1 = 0 ;
19373 PyObject *swig_obj[1] ;
19374
19375 if (!args) SWIG_fail;
19376 swig_obj[0] = args;
19377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19378 if (!SWIG_IsOK(res1)) {
19379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19380 }
19381 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19382 {
19383 PyThreadState* __tstate = wxPyBeginAllowThreads();
19384 result = (bool)(arg1)->MetaDown();
19385 wxPyEndAllowThreads(__tstate);
19386 if (PyErr_Occurred()) SWIG_fail;
19387 }
19388 {
19389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19390 }
19391 return resultobj;
19392 fail:
19393 return NULL;
19394 }
19395
19396
19397 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19398 PyObject *resultobj = 0;
19399 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19400 bool result;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject *swig_obj[1] ;
19404
19405 if (!args) SWIG_fail;
19406 swig_obj[0] = args;
19407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19408 if (!SWIG_IsOK(res1)) {
19409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19410 }
19411 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 result = (bool)(arg1)->ShiftDown();
19415 wxPyEndAllowThreads(__tstate);
19416 if (PyErr_Occurred()) SWIG_fail;
19417 }
19418 {
19419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19420 }
19421 return resultobj;
19422 fail:
19423 return NULL;
19424 }
19425
19426
19427 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19428 PyObject *resultobj = 0;
19429 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19430 bool result;
19431 void *argp1 = 0 ;
19432 int res1 = 0 ;
19433 PyObject *swig_obj[1] ;
19434
19435 if (!args) SWIG_fail;
19436 swig_obj[0] = args;
19437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19438 if (!SWIG_IsOK(res1)) {
19439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19440 }
19441 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19442 {
19443 PyThreadState* __tstate = wxPyBeginAllowThreads();
19444 result = (bool)(arg1)->AltDown();
19445 wxPyEndAllowThreads(__tstate);
19446 if (PyErr_Occurred()) SWIG_fail;
19447 }
19448 {
19449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19450 }
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19458 PyObject *resultobj = 0;
19459 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19460 bool result;
19461 void *argp1 = 0 ;
19462 int res1 = 0 ;
19463 PyObject *swig_obj[1] ;
19464
19465 if (!args) SWIG_fail;
19466 swig_obj[0] = args;
19467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19468 if (!SWIG_IsOK(res1)) {
19469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19470 }
19471 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19472 {
19473 PyThreadState* __tstate = wxPyBeginAllowThreads();
19474 result = (bool)(arg1)->CmdDown();
19475 wxPyEndAllowThreads(__tstate);
19476 if (PyErr_Occurred()) SWIG_fail;
19477 }
19478 {
19479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19480 }
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19488 PyObject *obj;
19489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19490 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19491 return SWIG_Py_Void();
19492 }
19493
19494 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19495 return SWIG_Python_InitShadowInstance(args);
19496 }
19497
19498 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19499 PyObject *resultobj = 0;
19500 int arg1 ;
19501 wxEventType arg2 ;
19502 wxGrid *arg3 = (wxGrid *) 0 ;
19503 wxGridCellCoords *arg4 = 0 ;
19504 wxGridCellCoords *arg5 = 0 ;
19505 bool arg6 = (bool) true ;
19506 bool arg7 = (bool) false ;
19507 bool arg8 = (bool) false ;
19508 bool arg9 = (bool) false ;
19509 bool arg10 = (bool) false ;
19510 wxGridRangeSelectEvent *result = 0 ;
19511 int val1 ;
19512 int ecode1 = 0 ;
19513 int val2 ;
19514 int ecode2 = 0 ;
19515 void *argp3 = 0 ;
19516 int res3 = 0 ;
19517 wxGridCellCoords temp4 ;
19518 wxGridCellCoords temp5 ;
19519 bool val6 ;
19520 int ecode6 = 0 ;
19521 bool val7 ;
19522 int ecode7 = 0 ;
19523 bool val8 ;
19524 int ecode8 = 0 ;
19525 bool val9 ;
19526 int ecode9 = 0 ;
19527 bool val10 ;
19528 int ecode10 = 0 ;
19529 PyObject * obj0 = 0 ;
19530 PyObject * obj1 = 0 ;
19531 PyObject * obj2 = 0 ;
19532 PyObject * obj3 = 0 ;
19533 PyObject * obj4 = 0 ;
19534 PyObject * obj5 = 0 ;
19535 PyObject * obj6 = 0 ;
19536 PyObject * obj7 = 0 ;
19537 PyObject * obj8 = 0 ;
19538 PyObject * obj9 = 0 ;
19539 char * kwnames[] = {
19540 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19541 };
19542
19543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19544 ecode1 = SWIG_AsVal_int(obj0, &val1);
19545 if (!SWIG_IsOK(ecode1)) {
19546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19547 }
19548 arg1 = static_cast< int >(val1);
19549 ecode2 = SWIG_AsVal_int(obj1, &val2);
19550 if (!SWIG_IsOK(ecode2)) {
19551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19552 }
19553 arg2 = static_cast< wxEventType >(val2);
19554 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19555 if (!SWIG_IsOK(res3)) {
19556 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19557 }
19558 arg3 = reinterpret_cast< wxGrid * >(argp3);
19559 {
19560 arg4 = &temp4;
19561 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19562 }
19563 {
19564 arg5 = &temp5;
19565 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19566 }
19567 if (obj5) {
19568 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19569 if (!SWIG_IsOK(ecode6)) {
19570 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19571 }
19572 arg6 = static_cast< bool >(val6);
19573 }
19574 if (obj6) {
19575 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19576 if (!SWIG_IsOK(ecode7)) {
19577 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19578 }
19579 arg7 = static_cast< bool >(val7);
19580 }
19581 if (obj7) {
19582 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19583 if (!SWIG_IsOK(ecode8)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19585 }
19586 arg8 = static_cast< bool >(val8);
19587 }
19588 if (obj8) {
19589 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19590 if (!SWIG_IsOK(ecode9)) {
19591 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19592 }
19593 arg9 = static_cast< bool >(val9);
19594 }
19595 if (obj9) {
19596 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19597 if (!SWIG_IsOK(ecode10)) {
19598 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19599 }
19600 arg10 = static_cast< bool >(val10);
19601 }
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19605 wxPyEndAllowThreads(__tstate);
19606 if (PyErr_Occurred()) SWIG_fail;
19607 }
19608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19609 return resultobj;
19610 fail:
19611 return NULL;
19612 }
19613
19614
19615 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19616 PyObject *resultobj = 0;
19617 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19618 wxGridCellCoords result;
19619 void *argp1 = 0 ;
19620 int res1 = 0 ;
19621 PyObject *swig_obj[1] ;
19622
19623 if (!args) SWIG_fail;
19624 swig_obj[0] = args;
19625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19628 }
19629 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 result = (arg1)->GetTopLeftCoords();
19633 wxPyEndAllowThreads(__tstate);
19634 if (PyErr_Occurred()) SWIG_fail;
19635 }
19636 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19637 return resultobj;
19638 fail:
19639 return NULL;
19640 }
19641
19642
19643 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19644 PyObject *resultobj = 0;
19645 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19646 wxGridCellCoords result;
19647 void *argp1 = 0 ;
19648 int res1 = 0 ;
19649 PyObject *swig_obj[1] ;
19650
19651 if (!args) SWIG_fail;
19652 swig_obj[0] = args;
19653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19654 if (!SWIG_IsOK(res1)) {
19655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19656 }
19657 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = (arg1)->GetBottomRightCoords();
19661 wxPyEndAllowThreads(__tstate);
19662 if (PyErr_Occurred()) SWIG_fail;
19663 }
19664 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19672 PyObject *resultobj = 0;
19673 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19674 int result;
19675 void *argp1 = 0 ;
19676 int res1 = 0 ;
19677 PyObject *swig_obj[1] ;
19678
19679 if (!args) SWIG_fail;
19680 swig_obj[0] = args;
19681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19682 if (!SWIG_IsOK(res1)) {
19683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19684 }
19685 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = (int)(arg1)->GetTopRow();
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_From_int(static_cast< int >(result));
19693 return resultobj;
19694 fail:
19695 return NULL;
19696 }
19697
19698
19699 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19700 PyObject *resultobj = 0;
19701 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19702 int result;
19703 void *argp1 = 0 ;
19704 int res1 = 0 ;
19705 PyObject *swig_obj[1] ;
19706
19707 if (!args) SWIG_fail;
19708 swig_obj[0] = args;
19709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19710 if (!SWIG_IsOK(res1)) {
19711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19712 }
19713 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = (int)(arg1)->GetBottomRow();
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_From_int(static_cast< int >(result));
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19728 PyObject *resultobj = 0;
19729 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19730 int result;
19731 void *argp1 = 0 ;
19732 int res1 = 0 ;
19733 PyObject *swig_obj[1] ;
19734
19735 if (!args) SWIG_fail;
19736 swig_obj[0] = args;
19737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19738 if (!SWIG_IsOK(res1)) {
19739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19740 }
19741 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 result = (int)(arg1)->GetLeftCol();
19745 wxPyEndAllowThreads(__tstate);
19746 if (PyErr_Occurred()) SWIG_fail;
19747 }
19748 resultobj = SWIG_From_int(static_cast< int >(result));
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19756 PyObject *resultobj = 0;
19757 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19758 int result;
19759 void *argp1 = 0 ;
19760 int res1 = 0 ;
19761 PyObject *swig_obj[1] ;
19762
19763 if (!args) SWIG_fail;
19764 swig_obj[0] = args;
19765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19766 if (!SWIG_IsOK(res1)) {
19767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19768 }
19769 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19770 {
19771 PyThreadState* __tstate = wxPyBeginAllowThreads();
19772 result = (int)(arg1)->GetRightCol();
19773 wxPyEndAllowThreads(__tstate);
19774 if (PyErr_Occurred()) SWIG_fail;
19775 }
19776 resultobj = SWIG_From_int(static_cast< int >(result));
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19784 PyObject *resultobj = 0;
19785 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19786 bool result;
19787 void *argp1 = 0 ;
19788 int res1 = 0 ;
19789 PyObject *swig_obj[1] ;
19790
19791 if (!args) SWIG_fail;
19792 swig_obj[0] = args;
19793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19794 if (!SWIG_IsOK(res1)) {
19795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19796 }
19797 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19798 {
19799 PyThreadState* __tstate = wxPyBeginAllowThreads();
19800 result = (bool)(arg1)->Selecting();
19801 wxPyEndAllowThreads(__tstate);
19802 if (PyErr_Occurred()) SWIG_fail;
19803 }
19804 {
19805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19806 }
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19814 PyObject *resultobj = 0;
19815 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19816 bool result;
19817 void *argp1 = 0 ;
19818 int res1 = 0 ;
19819 PyObject *swig_obj[1] ;
19820
19821 if (!args) SWIG_fail;
19822 swig_obj[0] = args;
19823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19824 if (!SWIG_IsOK(res1)) {
19825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19826 }
19827 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19828 {
19829 PyThreadState* __tstate = wxPyBeginAllowThreads();
19830 result = (bool)(arg1)->ControlDown();
19831 wxPyEndAllowThreads(__tstate);
19832 if (PyErr_Occurred()) SWIG_fail;
19833 }
19834 {
19835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19836 }
19837 return resultobj;
19838 fail:
19839 return NULL;
19840 }
19841
19842
19843 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19844 PyObject *resultobj = 0;
19845 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19846 bool result;
19847 void *argp1 = 0 ;
19848 int res1 = 0 ;
19849 PyObject *swig_obj[1] ;
19850
19851 if (!args) SWIG_fail;
19852 swig_obj[0] = args;
19853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19854 if (!SWIG_IsOK(res1)) {
19855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19856 }
19857 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19858 {
19859 PyThreadState* __tstate = wxPyBeginAllowThreads();
19860 result = (bool)(arg1)->MetaDown();
19861 wxPyEndAllowThreads(__tstate);
19862 if (PyErr_Occurred()) SWIG_fail;
19863 }
19864 {
19865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19866 }
19867 return resultobj;
19868 fail:
19869 return NULL;
19870 }
19871
19872
19873 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19874 PyObject *resultobj = 0;
19875 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19876 bool result;
19877 void *argp1 = 0 ;
19878 int res1 = 0 ;
19879 PyObject *swig_obj[1] ;
19880
19881 if (!args) SWIG_fail;
19882 swig_obj[0] = args;
19883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19884 if (!SWIG_IsOK(res1)) {
19885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19886 }
19887 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19888 {
19889 PyThreadState* __tstate = wxPyBeginAllowThreads();
19890 result = (bool)(arg1)->ShiftDown();
19891 wxPyEndAllowThreads(__tstate);
19892 if (PyErr_Occurred()) SWIG_fail;
19893 }
19894 {
19895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19896 }
19897 return resultobj;
19898 fail:
19899 return NULL;
19900 }
19901
19902
19903 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19904 PyObject *resultobj = 0;
19905 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19906 bool result;
19907 void *argp1 = 0 ;
19908 int res1 = 0 ;
19909 PyObject *swig_obj[1] ;
19910
19911 if (!args) SWIG_fail;
19912 swig_obj[0] = args;
19913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19914 if (!SWIG_IsOK(res1)) {
19915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19916 }
19917 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 result = (bool)(arg1)->AltDown();
19921 wxPyEndAllowThreads(__tstate);
19922 if (PyErr_Occurred()) SWIG_fail;
19923 }
19924 {
19925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19926 }
19927 return resultobj;
19928 fail:
19929 return NULL;
19930 }
19931
19932
19933 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19934 PyObject *resultobj = 0;
19935 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19936 bool result;
19937 void *argp1 = 0 ;
19938 int res1 = 0 ;
19939 PyObject *swig_obj[1] ;
19940
19941 if (!args) SWIG_fail;
19942 swig_obj[0] = args;
19943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19944 if (!SWIG_IsOK(res1)) {
19945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19946 }
19947 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 result = (bool)(arg1)->CmdDown();
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 {
19955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19956 }
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19964 PyObject *obj;
19965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19966 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
19967 return SWIG_Py_Void();
19968 }
19969
19970 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19971 return SWIG_Python_InitShadowInstance(args);
19972 }
19973
19974 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19975 PyObject *resultobj = 0;
19976 int arg1 ;
19977 wxEventType arg2 ;
19978 wxObject *arg3 = (wxObject *) 0 ;
19979 int arg4 ;
19980 int arg5 ;
19981 wxControl *arg6 = (wxControl *) 0 ;
19982 wxGridEditorCreatedEvent *result = 0 ;
19983 int val1 ;
19984 int ecode1 = 0 ;
19985 int val2 ;
19986 int ecode2 = 0 ;
19987 void *argp3 = 0 ;
19988 int res3 = 0 ;
19989 int val4 ;
19990 int ecode4 = 0 ;
19991 int val5 ;
19992 int ecode5 = 0 ;
19993 void *argp6 = 0 ;
19994 int res6 = 0 ;
19995 PyObject * obj0 = 0 ;
19996 PyObject * obj1 = 0 ;
19997 PyObject * obj2 = 0 ;
19998 PyObject * obj3 = 0 ;
19999 PyObject * obj4 = 0 ;
20000 PyObject * obj5 = 0 ;
20001 char * kwnames[] = {
20002 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20003 };
20004
20005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20006 ecode1 = SWIG_AsVal_int(obj0, &val1);
20007 if (!SWIG_IsOK(ecode1)) {
20008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20009 }
20010 arg1 = static_cast< int >(val1);
20011 ecode2 = SWIG_AsVal_int(obj1, &val2);
20012 if (!SWIG_IsOK(ecode2)) {
20013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20014 }
20015 arg2 = static_cast< wxEventType >(val2);
20016 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20017 if (!SWIG_IsOK(res3)) {
20018 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20019 }
20020 arg3 = reinterpret_cast< wxObject * >(argp3);
20021 ecode4 = SWIG_AsVal_int(obj3, &val4);
20022 if (!SWIG_IsOK(ecode4)) {
20023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20024 }
20025 arg4 = static_cast< int >(val4);
20026 ecode5 = SWIG_AsVal_int(obj4, &val5);
20027 if (!SWIG_IsOK(ecode5)) {
20028 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20029 }
20030 arg5 = static_cast< int >(val5);
20031 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20032 if (!SWIG_IsOK(res6)) {
20033 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20034 }
20035 arg6 = reinterpret_cast< wxControl * >(argp6);
20036 {
20037 PyThreadState* __tstate = wxPyBeginAllowThreads();
20038 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20039 wxPyEndAllowThreads(__tstate);
20040 if (PyErr_Occurred()) SWIG_fail;
20041 }
20042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20043 return resultobj;
20044 fail:
20045 return NULL;
20046 }
20047
20048
20049 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20050 PyObject *resultobj = 0;
20051 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20052 int result;
20053 void *argp1 = 0 ;
20054 int res1 = 0 ;
20055 PyObject *swig_obj[1] ;
20056
20057 if (!args) SWIG_fail;
20058 swig_obj[0] = args;
20059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20060 if (!SWIG_IsOK(res1)) {
20061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20062 }
20063 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20064 {
20065 PyThreadState* __tstate = wxPyBeginAllowThreads();
20066 result = (int)(arg1)->GetRow();
20067 wxPyEndAllowThreads(__tstate);
20068 if (PyErr_Occurred()) SWIG_fail;
20069 }
20070 resultobj = SWIG_From_int(static_cast< int >(result));
20071 return resultobj;
20072 fail:
20073 return NULL;
20074 }
20075
20076
20077 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20078 PyObject *resultobj = 0;
20079 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20080 int result;
20081 void *argp1 = 0 ;
20082 int res1 = 0 ;
20083 PyObject *swig_obj[1] ;
20084
20085 if (!args) SWIG_fail;
20086 swig_obj[0] = args;
20087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20088 if (!SWIG_IsOK(res1)) {
20089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20090 }
20091 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20092 {
20093 PyThreadState* __tstate = wxPyBeginAllowThreads();
20094 result = (int)(arg1)->GetCol();
20095 wxPyEndAllowThreads(__tstate);
20096 if (PyErr_Occurred()) SWIG_fail;
20097 }
20098 resultobj = SWIG_From_int(static_cast< int >(result));
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20106 PyObject *resultobj = 0;
20107 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20108 wxControl *result = 0 ;
20109 void *argp1 = 0 ;
20110 int res1 = 0 ;
20111 PyObject *swig_obj[1] ;
20112
20113 if (!args) SWIG_fail;
20114 swig_obj[0] = args;
20115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20116 if (!SWIG_IsOK(res1)) {
20117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20118 }
20119 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20120 {
20121 PyThreadState* __tstate = wxPyBeginAllowThreads();
20122 result = (wxControl *)(arg1)->GetControl();
20123 wxPyEndAllowThreads(__tstate);
20124 if (PyErr_Occurred()) SWIG_fail;
20125 }
20126 {
20127 resultobj = wxPyMake_wxObject(result, 0);
20128 }
20129 return resultobj;
20130 fail:
20131 return NULL;
20132 }
20133
20134
20135 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20136 PyObject *resultobj = 0;
20137 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20138 int arg2 ;
20139 void *argp1 = 0 ;
20140 int res1 = 0 ;
20141 int val2 ;
20142 int ecode2 = 0 ;
20143 PyObject * obj0 = 0 ;
20144 PyObject * obj1 = 0 ;
20145 char * kwnames[] = {
20146 (char *) "self",(char *) "row", NULL
20147 };
20148
20149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20151 if (!SWIG_IsOK(res1)) {
20152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20153 }
20154 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20155 ecode2 = SWIG_AsVal_int(obj1, &val2);
20156 if (!SWIG_IsOK(ecode2)) {
20157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20158 }
20159 arg2 = static_cast< int >(val2);
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 (arg1)->SetRow(arg2);
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 resultobj = SWIG_Py_Void();
20167 return resultobj;
20168 fail:
20169 return NULL;
20170 }
20171
20172
20173 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20174 PyObject *resultobj = 0;
20175 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20176 int arg2 ;
20177 void *argp1 = 0 ;
20178 int res1 = 0 ;
20179 int val2 ;
20180 int ecode2 = 0 ;
20181 PyObject * obj0 = 0 ;
20182 PyObject * obj1 = 0 ;
20183 char * kwnames[] = {
20184 (char *) "self",(char *) "col", NULL
20185 };
20186
20187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20189 if (!SWIG_IsOK(res1)) {
20190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20191 }
20192 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20193 ecode2 = SWIG_AsVal_int(obj1, &val2);
20194 if (!SWIG_IsOK(ecode2)) {
20195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20196 }
20197 arg2 = static_cast< int >(val2);
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 (arg1)->SetCol(arg2);
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 resultobj = SWIG_Py_Void();
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20212 PyObject *resultobj = 0;
20213 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20214 wxControl *arg2 = (wxControl *) 0 ;
20215 void *argp1 = 0 ;
20216 int res1 = 0 ;
20217 void *argp2 = 0 ;
20218 int res2 = 0 ;
20219 PyObject * obj0 = 0 ;
20220 PyObject * obj1 = 0 ;
20221 char * kwnames[] = {
20222 (char *) "self",(char *) "ctrl", NULL
20223 };
20224
20225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20227 if (!SWIG_IsOK(res1)) {
20228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20229 }
20230 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20231 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20232 if (!SWIG_IsOK(res2)) {
20233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20234 }
20235 arg2 = reinterpret_cast< wxControl * >(argp2);
20236 {
20237 PyThreadState* __tstate = wxPyBeginAllowThreads();
20238 (arg1)->SetControl(arg2);
20239 wxPyEndAllowThreads(__tstate);
20240 if (PyErr_Occurred()) SWIG_fail;
20241 }
20242 resultobj = SWIG_Py_Void();
20243 return resultobj;
20244 fail:
20245 return NULL;
20246 }
20247
20248
20249 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20250 PyObject *obj;
20251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20252 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20253 return SWIG_Py_Void();
20254 }
20255
20256 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20257 return SWIG_Python_InitShadowInstance(args);
20258 }
20259
20260 static PyMethodDef SwigMethods[] = {
20261 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20262 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20263 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20264 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20265 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20266 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20267 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20268 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20269 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20270 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20271 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20272 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20273 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20274 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20275 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20276 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20277 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20278 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20279 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20280 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20281 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20282 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20283 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20284 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20285 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20286 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20287 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20288 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20289 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20290 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20291 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20292 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20293 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20294 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20295 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20296 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20297 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20298 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20299 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20300 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20301 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20302 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20303 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20304 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20305 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20306 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20307 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20308 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20309 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20310 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20311 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20312 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20313 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20314 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20315 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20316 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20317 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20318 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20319 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20320 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20321 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20322 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20323 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20324 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20325 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20326 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20327 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20328 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20329 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20330 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20331 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20332 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20333 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
20334 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20335 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20336 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20337 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
20338 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20339 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20340 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20341 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20342 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20343 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20344 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20345 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20346 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20347 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20348 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20349 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20350 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20351 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20352 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20353 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20354 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20355 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20356 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20357 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20358 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20359 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20360 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20361 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20362 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20363 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20364 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20365 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20366 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20367 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20368 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20369 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20370 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20371 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20372 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20373 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20374 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20375 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20376 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20377 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20378 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20379 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20380 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20381 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20382 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20383 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20384 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20385 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20386 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20388 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20389 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20391 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20392 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20393 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20394 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20395 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20396 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20397 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20401 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20402 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20403 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20404 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20405 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20406 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20407 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20408 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20409 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20410 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20411 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20415 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20416 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20419 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20422 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20423 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20424 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20425 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20426 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20427 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20430 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20431 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20432 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20433 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20434 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20435 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20436 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20438 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20439 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20440 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20441 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20442 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20443 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20444 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20445 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20446 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20447 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20448 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20449 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20450 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20451 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20452 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20453 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20454 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20455 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20456 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20457 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20458 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20459 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20460 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20461 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20462 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20464 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20465 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20466 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20467 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20468 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20469 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20470 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20471 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20472 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20473 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20474 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20475 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20476 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20477 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20478 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20479 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20481 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20482 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20483 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20484 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20485 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20486 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20490 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20492 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20493 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20494 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20495 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20496 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20497 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20500 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20501 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20502 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20503 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20504 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20505 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20506 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20507 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20510 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20514 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20515 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20523 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20524 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20529 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20530 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20531 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20532 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20533 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20534 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20535 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20536 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20537 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20538 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20541 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20542 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20543 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20544 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20560 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20561 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20563 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20564 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20566 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20567 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20568 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20569 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20570 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20571 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20572 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20573 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20583 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20584 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20586 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20588 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20590 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20592 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20594 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20596 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20610 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20617 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20618 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20632 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20636 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20645 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20646 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20647 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20649 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20650 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20651 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20652 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20653 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20658 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20659 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20668 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20669 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20670 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20671 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20674 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20675 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20679 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20680 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20682 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20683 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20684 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20685 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20686 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20687 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20688 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20689 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20690 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20691 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20692 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20694 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20695 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20696 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20697 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20698 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20699 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20700 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20701 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20702 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20704 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20705 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20706 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20707 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20708 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20709 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20710 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20711 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20712 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20713 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20714 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20715 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20716 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20717 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20719 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20720 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20721 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20725 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20726 { NULL, NULL, 0, NULL }
20727 };
20728
20729
20730 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20731
20732 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20733 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20734 }
20735 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20736 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20737 }
20738 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20739 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20740 }
20741 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20742 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20743 }
20744 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20745 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20746 }
20747 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20748 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20749 }
20750 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20751 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20752 }
20753 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20754 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20755 }
20756 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20757 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20758 }
20759 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20760 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20761 }
20762 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20763 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20764 }
20765 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20766 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20767 }
20768 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20769 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20770 }
20771 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20772 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20773 }
20774 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20775 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20776 }
20777 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20778 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20779 }
20780 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20781 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20782 }
20783 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20784 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20785 }
20786 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20787 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20788 }
20789 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20790 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20791 }
20792 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20793 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20794 }
20795 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20796 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20797 }
20798 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20799 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20800 }
20801 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20802 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20803 }
20804 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20805 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20806 }
20807 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20808 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20809 }
20810 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20811 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20812 }
20813 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20814 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20815 }
20816 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20817 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20818 }
20819 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20820 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20821 }
20822 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20823 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20824 }
20825 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20826 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20827 }
20828 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20829 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20830 }
20831 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20832 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20833 }
20834 static void *_p_wxGridTo_p_wxPanel(void *x) {
20835 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20836 }
20837 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20838 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20839 }
20840 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20841 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20842 }
20843 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20844 return (void *)((wxPanel *) ((wxPyPanel *) x));
20845 }
20846 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20847 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20848 }
20849 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20850 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20851 }
20852 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20853 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20854 }
20855 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20856 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20857 }
20858 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20859 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20860 }
20861 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20862 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20863 }
20864 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20865 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20866 }
20867 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20868 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20869 }
20870 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20871 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20872 }
20873 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20874 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20875 }
20876 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20877 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20878 }
20879 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20880 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20881 }
20882 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20883 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20884 }
20885 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20886 return (void *)((wxWindow *) ((wxMenuBar *) x));
20887 }
20888 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
20889 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20890 }
20891 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
20892 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20893 }
20894 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
20895 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20896 }
20897 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
20898 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20899 }
20900 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
20901 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20902 }
20903 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
20904 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20905 }
20906 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
20907 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20908 }
20909 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
20910 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20911 }
20912 static void *_p_wxPanelTo_p_wxWindow(void *x) {
20913 return (void *)((wxWindow *) ((wxPanel *) x));
20914 }
20915 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
20916 return (void *)((wxWindow *) ((wxStatusBar *) x));
20917 }
20918 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
20919 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
20920 }
20921 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
20922 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
20923 }
20924 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
20925 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
20926 }
20927 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
20928 return (void *)((wxWindow *) ((wxPopupWindow *) x));
20929 }
20930 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
20931 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
20932 }
20933 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
20934 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
20935 }
20936 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
20937 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
20938 }
20939 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
20940 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
20941 }
20942 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
20943 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
20944 }
20945 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
20946 return (void *)((wxWindow *) ((wxSashWindow *) x));
20947 }
20948 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
20949 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
20950 }
20951 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
20952 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20953 }
20954 static void *_p_wxControlTo_p_wxWindow(void *x) {
20955 return (void *)((wxWindow *) ((wxControl *) x));
20956 }
20957 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
20958 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20959 }
20960 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
20961 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20962 }
20963 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
20964 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
20965 }
20966 static void *_p_wxGridTo_p_wxWindow(void *x) {
20967 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
20968 }
20969 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
20970 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
20971 }
20972 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
20973 return (void *)((wxWindow *) ((wxPyWindow *) x));
20974 }
20975 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
20976 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20977 }
20978 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
20979 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20980 }
20981 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
20982 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20983 }
20984 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
20985 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
20986 }
20987 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
20988 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20989 }
20990 static void *_p_wxFrameTo_p_wxWindow(void *x) {
20991 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
20992 }
20993 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
20994 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
20995 }
20996 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
20997 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
20998 }
20999 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21000 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21001 }
21002 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21003 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21004 }
21005 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21006 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21007 }
21008 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21009 return (void *)((wxControl *) ((wxControlWithItems *) x));
21010 }
21011 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21012 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21013 }
21014 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21015 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21016 }
21017 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21018 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21019 }
21020 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21021 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21022 }
21023 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21024 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21025 }
21026 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21027 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21028 }
21029 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21030 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21031 }
21032 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21033 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21034 }
21035 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21036 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21037 }
21038 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21039 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21040 }
21041 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21042 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21043 }
21044 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21045 return (void *)((wxEvent *) ((wxPyEvent *) x));
21046 }
21047 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21048 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21049 }
21050 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21051 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21052 }
21053 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21054 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21055 }
21056 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21057 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21058 }
21059 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21060 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21061 }
21062 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21063 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21064 }
21065 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21066 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21067 }
21068 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21069 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21070 }
21071 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21072 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21073 }
21074 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21075 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21076 }
21077 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21078 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21079 }
21080 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21081 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21082 }
21083 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21084 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21085 }
21086 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21087 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21088 }
21089 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21090 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21091 }
21092 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21093 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21094 }
21095 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21096 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21097 }
21098 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21099 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21100 }
21101 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21102 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21103 }
21104 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21105 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21106 }
21107 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21108 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21109 }
21110 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21111 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21112 }
21113 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21114 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21115 }
21116 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21117 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21118 }
21119 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21120 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21121 }
21122 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21123 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21124 }
21125 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21126 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21127 }
21128 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21129 return (void *)((wxEvent *) ((wxShowEvent *) x));
21130 }
21131 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21132 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21133 }
21134 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21135 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21136 }
21137 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21138 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21139 }
21140 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21141 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21142 }
21143 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21144 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21145 }
21146 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21147 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21148 }
21149 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21150 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21151 }
21152 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21153 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21154 }
21155 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21156 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21157 }
21158 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21159 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21160 }
21161 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21162 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21163 }
21164 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21165 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21166 }
21167 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21168 return (void *)((wxObject *) ((wxSizerItem *) x));
21169 }
21170 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21171 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21172 }
21173 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21174 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21175 }
21176 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21177 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21178 }
21179 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21180 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21181 }
21182 static void *_p_wxSizerTo_p_wxObject(void *x) {
21183 return (void *)((wxObject *) ((wxSizer *) x));
21184 }
21185 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21186 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21187 }
21188 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21189 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21190 }
21191 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21192 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21193 }
21194 static void *_p_wxEventTo_p_wxObject(void *x) {
21195 return (void *)((wxObject *) ((wxEvent *) x));
21196 }
21197 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21198 return (void *)((wxObject *) ((wxFontData *) x));
21199 }
21200 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21201 return (void *)((wxObject *) ((wxPrintData *) x));
21202 }
21203 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21204 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21205 }
21206 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21207 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21208 }
21209 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21210 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21211 }
21212 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21213 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21214 }
21215 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21216 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21217 }
21218 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21219 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21220 }
21221 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21222 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21223 }
21224 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21225 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21226 }
21227 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21228 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21229 }
21230 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21231 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21232 }
21233 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21234 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21235 }
21236 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21237 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21238 }
21239 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21240 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21241 }
21242 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21243 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21244 }
21245 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21246 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21247 }
21248 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21249 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21250 }
21251 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21252 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21253 }
21254 static void *_p_wxControlTo_p_wxObject(void *x) {
21255 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21256 }
21257 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21258 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21259 }
21260 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21261 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21262 }
21263 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21264 return (void *)((wxObject *) ((wxFSFile *) x));
21265 }
21266 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21267 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21268 }
21269 static void *_p_wxGridTo_p_wxObject(void *x) {
21270 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21271 }
21272 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21273 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21274 }
21275 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21276 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21277 }
21278 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21279 return (void *)((wxObject *) ((wxColourData *) x));
21280 }
21281 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21282 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21283 }
21284 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21285 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21286 }
21287 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21288 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21289 }
21290 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21291 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21292 }
21293 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21294 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21295 }
21296 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21297 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21298 }
21299 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21300 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21301 }
21302 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21303 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21304 }
21305 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21306 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21307 }
21308 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21309 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21310 }
21311 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21312 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21313 }
21314 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21315 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21316 }
21317 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21318 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21319 }
21320 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21321 return (void *)((wxObject *) ((wxPrinter *) x));
21322 }
21323 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21324 return (void *)((wxObject *) ((wxMenuItem *) x));
21325 }
21326 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21327 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21328 }
21329 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21330 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21331 }
21332 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21333 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21334 }
21335 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21336 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21337 }
21338 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21339 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21340 }
21341 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21342 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21343 }
21344 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21345 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21346 }
21347 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21348 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21349 }
21350 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21351 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21352 }
21353 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21354 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21355 }
21356 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21357 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21358 }
21359 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21360 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21361 }
21362 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21363 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21364 }
21365 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21366 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21367 }
21368 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21369 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21370 }
21371 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21372 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21373 }
21374 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21375 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21376 }
21377 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21378 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21379 }
21380 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21381 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21382 }
21383 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21384 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21385 }
21386 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21387 return (void *)((wxObject *) ((wxImageHandler *) x));
21388 }
21389 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21390 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21391 }
21392 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21393 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21394 }
21395 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21396 return (void *)((wxObject *) ((wxEvtHandler *) x));
21397 }
21398 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21399 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21400 }
21401 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21402 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21403 }
21404 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21405 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21406 }
21407 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21408 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21409 }
21410 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21411 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21412 }
21413 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21414 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21415 }
21416 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21417 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21418 }
21419 static void *_p_wxImageTo_p_wxObject(void *x) {
21420 return (void *)((wxObject *) ((wxImage *) x));
21421 }
21422 static void *_p_wxFrameTo_p_wxObject(void *x) {
21423 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21424 }
21425 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21426 return (void *)((wxObject *) ((wxPyPrintout *) x));
21427 }
21428 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21429 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21430 }
21431 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21432 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21433 }
21434 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21435 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21436 }
21437 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21438 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21439 }
21440 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21441 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21442 }
21443 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21444 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21445 }
21446 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21447 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21448 }
21449 static void *_p_wxWindowTo_p_wxObject(void *x) {
21450 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21451 }
21452 static void *_p_wxMenuTo_p_wxObject(void *x) {
21453 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21454 }
21455 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21456 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21457 }
21458 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21459 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21460 }
21461 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21462 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21463 }
21464 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21465 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21466 }
21467 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21468 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21469 }
21470 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21471 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21472 }
21473 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21474 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21475 }
21476 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21477 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21478 }
21479 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21480 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21481 }
21482 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21483 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21484 }
21485 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21486 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21487 }
21488 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21489 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21490 }
21491 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21492 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21493 }
21494 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21496 }
21497 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21498 return (void *)((wxObject *) ((wxPrintPreview *) x));
21499 }
21500 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21501 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21502 }
21503 static void *_p_wxPanelTo_p_wxObject(void *x) {
21504 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21505 }
21506 static void *_p_wxDialogTo_p_wxObject(void *x) {
21507 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21508 }
21509 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21510 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21511 }
21512 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21513 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21514 }
21515 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21516 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21517 }
21518 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21519 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21520 }
21521 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21522 return (void *)((wxObject *) ((wxPrintDialog *) x));
21523 }
21524 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21525 return (void *)((wxObject *) ((wxFileSystem *) x));
21526 }
21527 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21528 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21529 }
21530 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21531 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21532 }
21533 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21534 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21535 }
21536 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21537 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21538 }
21539 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21540 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21541 }
21542 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21543 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21544 }
21545 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21546 return (void *)((wxObject *) ((wxGridTableBase *) x));
21547 }
21548 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21549 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21550 }
21551 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21552 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21553 }
21554 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21555 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21556 }
21557 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21558 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21559 }
21560 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21561 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21562 }
21563 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21564 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21565 }
21566 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21567 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21568 }
21569 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21570 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21571 }
21572 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21573 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21574 }
21575 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21576 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21577 }
21578 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21579 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21580 }
21581 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21582 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21583 }
21584 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21585 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21586 }
21587 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21588 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21589 }
21590 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21591 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21592 }
21593 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21594 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21595 }
21596 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21597 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21598 }
21599 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21600 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21601 }
21602 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21603 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21604 }
21605 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21606 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21607 }
21608 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21609 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21610 }
21611 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21612 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21613 }
21614 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21615 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21616 }
21617 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21618 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21619 }
21620 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21621 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21622 }
21623 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21624 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21625 }
21626 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21627 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21628 }
21629 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21630 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21631 }
21632 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21633 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21634 }
21635 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21636 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21637 }
21638 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21639 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21640 }
21641 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21642 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21643 }
21644 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21645 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21646 }
21647 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21648 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21649 }
21650 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21651 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21652 }
21653 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21654 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21655 }
21656 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21657 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21658 }
21659 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21660 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21661 }
21662 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21663 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21664 }
21665 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21666 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21667 }
21668 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21669 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21670 }
21671 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21672 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21673 }
21674 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21675 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21676 }
21677 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21678 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21679 }
21680 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21681 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21682 }
21683 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21684 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21685 }
21686 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21687 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21688 }
21689 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21690 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21691 }
21692 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21693 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21694 }
21695 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21696 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21697 }
21698 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21699 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21700 }
21701 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21702 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21703 }
21704 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21705 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21706 }
21707 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21708 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21709 }
21710 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21711 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21712 }
21713 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21714 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21715 }
21716 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21717 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21718 }
21719 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21720 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21721 }
21722 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21723 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21724 }
21725 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21726 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21727 }
21728 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21729 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21730 }
21731 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21732 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21733 }
21734 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21735 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21736 }
21737 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21738 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21739 }
21740 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21741 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21742 }
21743 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21744 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21745 }
21746 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21747 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21748 }
21749 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21750 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21751 }
21752 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21753 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21754 }
21755 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21756 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21757 }
21758 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21759 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21760 }
21761 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21762 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21763 }
21764 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21765 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21766 }
21767 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21768 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21769 }
21770 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21771 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21772 }
21773 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21774 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21775 }
21776 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21777 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21778 }
21779 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21780 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21781 }
21782 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21783 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21784 }
21785 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
21786 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
21787 }
21788 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21789 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21790 }
21791 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21792 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21793 }
21794 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21795 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21796 }
21797 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21798 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21799 }
21800 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21801 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21802 }
21803 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21804 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21805 }
21806 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21807 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21808 }
21809 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21810 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21811 }
21812 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21813 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21814 }
21815 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21816 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21817 }
21818 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21819 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21820 }
21821 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21822 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21823 }
21824 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21825 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21826 }
21827 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21828 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21829 }
21830 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21831 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21832 }
21833 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21834 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};
21835 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21836 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21837 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21838 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21839 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21840 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21841 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21842 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21843 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21844 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21845 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21846 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
21847 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21848 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21849 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21850 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21851 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21852 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21853 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21854 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21855 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21856 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21857 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21858 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21859 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21860 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21861 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21862 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21863 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21864 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21865 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21866 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21867 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21868 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21869 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21870 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21871 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21872 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21873 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21874 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21875 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21876 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21877 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21878 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21879 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
21880 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
21881 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
21882 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
21883 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
21884 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
21885 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
21886 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
21887 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
21888 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
21889 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
21890 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
21891 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
21892 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
21893 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
21894 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
21895 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
21896 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
21897 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
21898 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
21899 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
21900 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
21901 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
21902 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
21903 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
21904 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
21905 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
21906 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
21907 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
21908 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
21909 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
21910 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
21911 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
21912 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
21913 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
21914 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
21915 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
21916 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
21917 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
21918 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
21919 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
21920 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
21921 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
21922 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
21923 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
21924 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
21925 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
21926 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
21927 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
21928 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
21929 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
21930 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
21931 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
21932 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
21933 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
21934 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
21935 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
21936 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
21937 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
21938 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
21939 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
21940 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
21941 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
21942 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
21943 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
21944 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
21945 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
21946 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
21947 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
21948 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
21949 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
21950 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
21951 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
21952 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
21953 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
21954 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
21955 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
21956 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
21957 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
21958 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
21959 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
21960 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
21961 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
21962 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
21963 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
21964 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
21965 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
21966 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
21967 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
21968 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
21969 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
21970 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
21971 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
21972 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
21973 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
21974 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
21975 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
21976 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
21977 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
21978 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
21979 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
21980 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
21981 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
21982 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
21983 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
21984 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
21985 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
21986 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
21987 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
21988 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
21989 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
21990 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
21991 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
21992 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
21993 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
21994 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
21995 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
21996 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
21997 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
21998 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
21999 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22000 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22001 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22002 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22003 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22004 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22005 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22006 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22007 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22008 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22009 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22010 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22011 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22012 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22013 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22014 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22015 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22016 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22017 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22018 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22019 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22020
22021 static swig_type_info *swig_type_initial[] = {
22022 &_swigt__p_char,
22023 &_swigt__p_form_ops_t,
22024 &_swigt__p_int,
22025 &_swigt__p_long,
22026 &_swigt__p_unsigned_char,
22027 &_swigt__p_unsigned_int,
22028 &_swigt__p_unsigned_long,
22029 &_swigt__p_wxANIHandler,
22030 &_swigt__p_wxAcceleratorTable,
22031 &_swigt__p_wxActivateEvent,
22032 &_swigt__p_wxArrayString,
22033 &_swigt__p_wxBMPHandler,
22034 &_swigt__p_wxBoxSizer,
22035 &_swigt__p_wxCURHandler,
22036 &_swigt__p_wxCalculateLayoutEvent,
22037 &_swigt__p_wxChildFocusEvent,
22038 &_swigt__p_wxClipboardTextEvent,
22039 &_swigt__p_wxCloseEvent,
22040 &_swigt__p_wxColour,
22041 &_swigt__p_wxColourData,
22042 &_swigt__p_wxColourDialog,
22043 &_swigt__p_wxCommandEvent,
22044 &_swigt__p_wxContextMenuEvent,
22045 &_swigt__p_wxControl,
22046 &_swigt__p_wxControlWithItems,
22047 &_swigt__p_wxDC,
22048 &_swigt__p_wxDateEvent,
22049 &_swigt__p_wxDialog,
22050 &_swigt__p_wxDirDialog,
22051 &_swigt__p_wxDisplayChangedEvent,
22052 &_swigt__p_wxDropFilesEvent,
22053 &_swigt__p_wxDuplexMode,
22054 &_swigt__p_wxEraseEvent,
22055 &_swigt__p_wxEvent,
22056 &_swigt__p_wxEvtHandler,
22057 &_swigt__p_wxFSFile,
22058 &_swigt__p_wxFileDialog,
22059 &_swigt__p_wxFileSystem,
22060 &_swigt__p_wxFindDialogEvent,
22061 &_swigt__p_wxFindReplaceData,
22062 &_swigt__p_wxFindReplaceDialog,
22063 &_swigt__p_wxFlexGridSizer,
22064 &_swigt__p_wxFocusEvent,
22065 &_swigt__p_wxFont,
22066 &_swigt__p_wxFontData,
22067 &_swigt__p_wxFontDialog,
22068 &_swigt__p_wxFrame,
22069 &_swigt__p_wxGBSizerItem,
22070 &_swigt__p_wxGIFHandler,
22071 &_swigt__p_wxGrid,
22072 &_swigt__p_wxGridBagSizer,
22073 &_swigt__p_wxGridCellAttr,
22074 &_swigt__p_wxGridCellAttrProvider,
22075 &_swigt__p_wxGridCellAutoWrapStringEditor,
22076 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22077 &_swigt__p_wxGridCellBoolEditor,
22078 &_swigt__p_wxGridCellBoolRenderer,
22079 &_swigt__p_wxGridCellChoiceEditor,
22080 &_swigt__p_wxGridCellCoords,
22081 &_swigt__p_wxGridCellDateTimeRenderer,
22082 &_swigt__p_wxGridCellEditor,
22083 &_swigt__p_wxGridCellEnumEditor,
22084 &_swigt__p_wxGridCellEnumRenderer,
22085 &_swigt__p_wxGridCellFloatEditor,
22086 &_swigt__p_wxGridCellFloatRenderer,
22087 &_swigt__p_wxGridCellNumberEditor,
22088 &_swigt__p_wxGridCellNumberRenderer,
22089 &_swigt__p_wxGridCellRenderer,
22090 &_swigt__p_wxGridCellStringRenderer,
22091 &_swigt__p_wxGridCellTextEditor,
22092 &_swigt__p_wxGridCellWorker,
22093 &_swigt__p_wxGridEditorCreatedEvent,
22094 &_swigt__p_wxGridEvent,
22095 &_swigt__p_wxGridRangeSelectEvent,
22096 &_swigt__p_wxGridSizeEvent,
22097 &_swigt__p_wxGridSizer,
22098 &_swigt__p_wxGridStringTable,
22099 &_swigt__p_wxGridTableBase,
22100 &_swigt__p_wxGridTableMessage,
22101 &_swigt__p_wxICOHandler,
22102 &_swigt__p_wxIconizeEvent,
22103 &_swigt__p_wxIdleEvent,
22104 &_swigt__p_wxImage,
22105 &_swigt__p_wxImageHandler,
22106 &_swigt__p_wxIndividualLayoutConstraint,
22107 &_swigt__p_wxInitDialogEvent,
22108 &_swigt__p_wxJPEGHandler,
22109 &_swigt__p_wxKeyEvent,
22110 &_swigt__p_wxLayoutAlgorithm,
22111 &_swigt__p_wxLayoutConstraints,
22112 &_swigt__p_wxMDIChildFrame,
22113 &_swigt__p_wxMDIClientWindow,
22114 &_swigt__p_wxMDIParentFrame,
22115 &_swigt__p_wxMaximizeEvent,
22116 &_swigt__p_wxMenu,
22117 &_swigt__p_wxMenuBar,
22118 &_swigt__p_wxMenuEvent,
22119 &_swigt__p_wxMenuItem,
22120 &_swigt__p_wxMessageDialog,
22121 &_swigt__p_wxMiniFrame,
22122 &_swigt__p_wxMouseCaptureChangedEvent,
22123 &_swigt__p_wxMouseEvent,
22124 &_swigt__p_wxMoveEvent,
22125 &_swigt__p_wxMultiChoiceDialog,
22126 &_swigt__p_wxNavigationKeyEvent,
22127 &_swigt__p_wxNcPaintEvent,
22128 &_swigt__p_wxNotifyEvent,
22129 &_swigt__p_wxObject,
22130 &_swigt__p_wxPCXHandler,
22131 &_swigt__p_wxPNGHandler,
22132 &_swigt__p_wxPNMHandler,
22133 &_swigt__p_wxPageSetupDialog,
22134 &_swigt__p_wxPageSetupDialogData,
22135 &_swigt__p_wxPaintEvent,
22136 &_swigt__p_wxPaletteChangedEvent,
22137 &_swigt__p_wxPanel,
22138 &_swigt__p_wxPaperSize,
22139 &_swigt__p_wxPasswordEntryDialog,
22140 &_swigt__p_wxPoint,
22141 &_swigt__p_wxPopupWindow,
22142 &_swigt__p_wxPreviewCanvas,
22143 &_swigt__p_wxPreviewControlBar,
22144 &_swigt__p_wxPreviewFrame,
22145 &_swigt__p_wxPrintData,
22146 &_swigt__p_wxPrintDialog,
22147 &_swigt__p_wxPrintDialogData,
22148 &_swigt__p_wxPrintPreview,
22149 &_swigt__p_wxPrinter,
22150 &_swigt__p_wxProgressDialog,
22151 &_swigt__p_wxPyApp,
22152 &_swigt__p_wxPyCommandEvent,
22153 &_swigt__p_wxPyEvent,
22154 &_swigt__p_wxPyGridCellAttrProvider,
22155 &_swigt__p_wxPyGridCellEditor,
22156 &_swigt__p_wxPyGridCellRenderer,
22157 &_swigt__p_wxPyGridTableBase,
22158 &_swigt__p_wxPyHtmlListBox,
22159 &_swigt__p_wxPyImageHandler,
22160 &_swigt__p_wxPyPanel,
22161 &_swigt__p_wxPyPopupTransientWindow,
22162 &_swigt__p_wxPyPreviewControlBar,
22163 &_swigt__p_wxPyPreviewFrame,
22164 &_swigt__p_wxPyPrintPreview,
22165 &_swigt__p_wxPyPrintout,
22166 &_swigt__p_wxPyScrolledWindow,
22167 &_swigt__p_wxPySizer,
22168 &_swigt__p_wxPyTaskBarIcon,
22169 &_swigt__p_wxPyVListBox,
22170 &_swigt__p_wxPyVScrolledWindow,
22171 &_swigt__p_wxPyValidator,
22172 &_swigt__p_wxPyWindow,
22173 &_swigt__p_wxQueryLayoutInfoEvent,
22174 &_swigt__p_wxQueryNewPaletteEvent,
22175 &_swigt__p_wxRect,
22176 &_swigt__p_wxSashEvent,
22177 &_swigt__p_wxSashLayoutWindow,
22178 &_swigt__p_wxSashWindow,
22179 &_swigt__p_wxScrollEvent,
22180 &_swigt__p_wxScrollWinEvent,
22181 &_swigt__p_wxScrolledWindow,
22182 &_swigt__p_wxSetCursorEvent,
22183 &_swigt__p_wxShowEvent,
22184 &_swigt__p_wxSingleChoiceDialog,
22185 &_swigt__p_wxSizeEvent,
22186 &_swigt__p_wxSizer,
22187 &_swigt__p_wxSizerItem,
22188 &_swigt__p_wxSplashScreen,
22189 &_swigt__p_wxSplashScreenWindow,
22190 &_swigt__p_wxSplitterEvent,
22191 &_swigt__p_wxSplitterWindow,
22192 &_swigt__p_wxStaticBoxSizer,
22193 &_swigt__p_wxStatusBar,
22194 &_swigt__p_wxStdDialogButtonSizer,
22195 &_swigt__p_wxString,
22196 &_swigt__p_wxSysColourChangedEvent,
22197 &_swigt__p_wxTIFFHandler,
22198 &_swigt__p_wxTaskBarIconEvent,
22199 &_swigt__p_wxTextEntryDialog,
22200 &_swigt__p_wxTipWindow,
22201 &_swigt__p_wxTopLevelWindow,
22202 &_swigt__p_wxUpdateUIEvent,
22203 &_swigt__p_wxValidator,
22204 &_swigt__p_wxVisualAttributes,
22205 &_swigt__p_wxWindow,
22206 &_swigt__p_wxWindowCreateEvent,
22207 &_swigt__p_wxWindowDestroyEvent,
22208 &_swigt__p_wxXPMHandler,
22209 };
22210
22211 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22212 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22213 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22214 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22215 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22216 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22217 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22218 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22219 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22220 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22221 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22222 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22223 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22224 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22225 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22226 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22227 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22228 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22229 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22230 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22231 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22232 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}};
22233 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22234 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}};
22235 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22236 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22237 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22238 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22239 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22240 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22241 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22242 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22243 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22244 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22245 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22246 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22247 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22248 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22249 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22250 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22251 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22252 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22253 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22254 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22255 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22256 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22257 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22258 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22259 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22260 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22261 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22262 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22263 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22264 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22265 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}};
22266 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22267 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22268 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22269 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22270 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22271 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22272 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22273 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22274 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22275 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22276 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22277 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22278 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22279 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22280 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22281 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22282 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22283 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22284 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22285 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22286 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22287 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22288 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22289 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22290 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22291 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22292 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22293 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22294 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22295 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22296 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22297 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22298 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22299 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22300 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22301 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22302 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22303 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22304 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22305 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22306 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22307 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22308 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22309 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22310 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}};
22311 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22312 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22313 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22314 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}};
22315 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22316 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22317 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22318 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22319 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}};
22320 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22321 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22322 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}};
22323 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22324 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22325 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22326 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22327 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22328 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22329 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}};
22330 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}};
22331 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}};
22332 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}};
22333 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22334 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22335 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22336 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22337 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22338 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}};
22339 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22340 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22341 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}};
22342 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22343 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22344 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22345 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22346 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22347 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22348 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22349 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22350 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22351 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22352 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22353 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22354 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22355 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22356 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22357 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22358 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22359 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22360 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22361 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22362 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22363 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22364 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22365 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22366 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22367 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22368 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22369 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22370 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22371 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22372 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22373 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22374 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22375 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22376 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22377 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22378 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22379 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22380 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22381 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22382 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22383 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22384 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22385 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}};
22386 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}};
22387 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22388 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22389 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22390 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22391 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22392 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22393 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22394 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}};
22395 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22396 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22397 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}};
22398
22399 static swig_cast_info *swig_cast_initial[] = {
22400 _swigc__p_char,
22401 _swigc__p_form_ops_t,
22402 _swigc__p_int,
22403 _swigc__p_long,
22404 _swigc__p_unsigned_char,
22405 _swigc__p_unsigned_int,
22406 _swigc__p_unsigned_long,
22407 _swigc__p_wxANIHandler,
22408 _swigc__p_wxAcceleratorTable,
22409 _swigc__p_wxActivateEvent,
22410 _swigc__p_wxArrayString,
22411 _swigc__p_wxBMPHandler,
22412 _swigc__p_wxBoxSizer,
22413 _swigc__p_wxCURHandler,
22414 _swigc__p_wxCalculateLayoutEvent,
22415 _swigc__p_wxChildFocusEvent,
22416 _swigc__p_wxClipboardTextEvent,
22417 _swigc__p_wxCloseEvent,
22418 _swigc__p_wxColour,
22419 _swigc__p_wxColourData,
22420 _swigc__p_wxColourDialog,
22421 _swigc__p_wxCommandEvent,
22422 _swigc__p_wxContextMenuEvent,
22423 _swigc__p_wxControl,
22424 _swigc__p_wxControlWithItems,
22425 _swigc__p_wxDC,
22426 _swigc__p_wxDateEvent,
22427 _swigc__p_wxDialog,
22428 _swigc__p_wxDirDialog,
22429 _swigc__p_wxDisplayChangedEvent,
22430 _swigc__p_wxDropFilesEvent,
22431 _swigc__p_wxDuplexMode,
22432 _swigc__p_wxEraseEvent,
22433 _swigc__p_wxEvent,
22434 _swigc__p_wxEvtHandler,
22435 _swigc__p_wxFSFile,
22436 _swigc__p_wxFileDialog,
22437 _swigc__p_wxFileSystem,
22438 _swigc__p_wxFindDialogEvent,
22439 _swigc__p_wxFindReplaceData,
22440 _swigc__p_wxFindReplaceDialog,
22441 _swigc__p_wxFlexGridSizer,
22442 _swigc__p_wxFocusEvent,
22443 _swigc__p_wxFont,
22444 _swigc__p_wxFontData,
22445 _swigc__p_wxFontDialog,
22446 _swigc__p_wxFrame,
22447 _swigc__p_wxGBSizerItem,
22448 _swigc__p_wxGIFHandler,
22449 _swigc__p_wxGrid,
22450 _swigc__p_wxGridBagSizer,
22451 _swigc__p_wxGridCellAttr,
22452 _swigc__p_wxGridCellAttrProvider,
22453 _swigc__p_wxGridCellAutoWrapStringEditor,
22454 _swigc__p_wxGridCellAutoWrapStringRenderer,
22455 _swigc__p_wxGridCellBoolEditor,
22456 _swigc__p_wxGridCellBoolRenderer,
22457 _swigc__p_wxGridCellChoiceEditor,
22458 _swigc__p_wxGridCellCoords,
22459 _swigc__p_wxGridCellDateTimeRenderer,
22460 _swigc__p_wxGridCellEditor,
22461 _swigc__p_wxGridCellEnumEditor,
22462 _swigc__p_wxGridCellEnumRenderer,
22463 _swigc__p_wxGridCellFloatEditor,
22464 _swigc__p_wxGridCellFloatRenderer,
22465 _swigc__p_wxGridCellNumberEditor,
22466 _swigc__p_wxGridCellNumberRenderer,
22467 _swigc__p_wxGridCellRenderer,
22468 _swigc__p_wxGridCellStringRenderer,
22469 _swigc__p_wxGridCellTextEditor,
22470 _swigc__p_wxGridCellWorker,
22471 _swigc__p_wxGridEditorCreatedEvent,
22472 _swigc__p_wxGridEvent,
22473 _swigc__p_wxGridRangeSelectEvent,
22474 _swigc__p_wxGridSizeEvent,
22475 _swigc__p_wxGridSizer,
22476 _swigc__p_wxGridStringTable,
22477 _swigc__p_wxGridTableBase,
22478 _swigc__p_wxGridTableMessage,
22479 _swigc__p_wxICOHandler,
22480 _swigc__p_wxIconizeEvent,
22481 _swigc__p_wxIdleEvent,
22482 _swigc__p_wxImage,
22483 _swigc__p_wxImageHandler,
22484 _swigc__p_wxIndividualLayoutConstraint,
22485 _swigc__p_wxInitDialogEvent,
22486 _swigc__p_wxJPEGHandler,
22487 _swigc__p_wxKeyEvent,
22488 _swigc__p_wxLayoutAlgorithm,
22489 _swigc__p_wxLayoutConstraints,
22490 _swigc__p_wxMDIChildFrame,
22491 _swigc__p_wxMDIClientWindow,
22492 _swigc__p_wxMDIParentFrame,
22493 _swigc__p_wxMaximizeEvent,
22494 _swigc__p_wxMenu,
22495 _swigc__p_wxMenuBar,
22496 _swigc__p_wxMenuEvent,
22497 _swigc__p_wxMenuItem,
22498 _swigc__p_wxMessageDialog,
22499 _swigc__p_wxMiniFrame,
22500 _swigc__p_wxMouseCaptureChangedEvent,
22501 _swigc__p_wxMouseEvent,
22502 _swigc__p_wxMoveEvent,
22503 _swigc__p_wxMultiChoiceDialog,
22504 _swigc__p_wxNavigationKeyEvent,
22505 _swigc__p_wxNcPaintEvent,
22506 _swigc__p_wxNotifyEvent,
22507 _swigc__p_wxObject,
22508 _swigc__p_wxPCXHandler,
22509 _swigc__p_wxPNGHandler,
22510 _swigc__p_wxPNMHandler,
22511 _swigc__p_wxPageSetupDialog,
22512 _swigc__p_wxPageSetupDialogData,
22513 _swigc__p_wxPaintEvent,
22514 _swigc__p_wxPaletteChangedEvent,
22515 _swigc__p_wxPanel,
22516 _swigc__p_wxPaperSize,
22517 _swigc__p_wxPasswordEntryDialog,
22518 _swigc__p_wxPoint,
22519 _swigc__p_wxPopupWindow,
22520 _swigc__p_wxPreviewCanvas,
22521 _swigc__p_wxPreviewControlBar,
22522 _swigc__p_wxPreviewFrame,
22523 _swigc__p_wxPrintData,
22524 _swigc__p_wxPrintDialog,
22525 _swigc__p_wxPrintDialogData,
22526 _swigc__p_wxPrintPreview,
22527 _swigc__p_wxPrinter,
22528 _swigc__p_wxProgressDialog,
22529 _swigc__p_wxPyApp,
22530 _swigc__p_wxPyCommandEvent,
22531 _swigc__p_wxPyEvent,
22532 _swigc__p_wxPyGridCellAttrProvider,
22533 _swigc__p_wxPyGridCellEditor,
22534 _swigc__p_wxPyGridCellRenderer,
22535 _swigc__p_wxPyGridTableBase,
22536 _swigc__p_wxPyHtmlListBox,
22537 _swigc__p_wxPyImageHandler,
22538 _swigc__p_wxPyPanel,
22539 _swigc__p_wxPyPopupTransientWindow,
22540 _swigc__p_wxPyPreviewControlBar,
22541 _swigc__p_wxPyPreviewFrame,
22542 _swigc__p_wxPyPrintPreview,
22543 _swigc__p_wxPyPrintout,
22544 _swigc__p_wxPyScrolledWindow,
22545 _swigc__p_wxPySizer,
22546 _swigc__p_wxPyTaskBarIcon,
22547 _swigc__p_wxPyVListBox,
22548 _swigc__p_wxPyVScrolledWindow,
22549 _swigc__p_wxPyValidator,
22550 _swigc__p_wxPyWindow,
22551 _swigc__p_wxQueryLayoutInfoEvent,
22552 _swigc__p_wxQueryNewPaletteEvent,
22553 _swigc__p_wxRect,
22554 _swigc__p_wxSashEvent,
22555 _swigc__p_wxSashLayoutWindow,
22556 _swigc__p_wxSashWindow,
22557 _swigc__p_wxScrollEvent,
22558 _swigc__p_wxScrollWinEvent,
22559 _swigc__p_wxScrolledWindow,
22560 _swigc__p_wxSetCursorEvent,
22561 _swigc__p_wxShowEvent,
22562 _swigc__p_wxSingleChoiceDialog,
22563 _swigc__p_wxSizeEvent,
22564 _swigc__p_wxSizer,
22565 _swigc__p_wxSizerItem,
22566 _swigc__p_wxSplashScreen,
22567 _swigc__p_wxSplashScreenWindow,
22568 _swigc__p_wxSplitterEvent,
22569 _swigc__p_wxSplitterWindow,
22570 _swigc__p_wxStaticBoxSizer,
22571 _swigc__p_wxStatusBar,
22572 _swigc__p_wxStdDialogButtonSizer,
22573 _swigc__p_wxString,
22574 _swigc__p_wxSysColourChangedEvent,
22575 _swigc__p_wxTIFFHandler,
22576 _swigc__p_wxTaskBarIconEvent,
22577 _swigc__p_wxTextEntryDialog,
22578 _swigc__p_wxTipWindow,
22579 _swigc__p_wxTopLevelWindow,
22580 _swigc__p_wxUpdateUIEvent,
22581 _swigc__p_wxValidator,
22582 _swigc__p_wxVisualAttributes,
22583 _swigc__p_wxWindow,
22584 _swigc__p_wxWindowCreateEvent,
22585 _swigc__p_wxWindowDestroyEvent,
22586 _swigc__p_wxXPMHandler,
22587 };
22588
22589
22590 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22591
22592 static swig_const_info swig_const_table[] = {
22593 {0, 0, 0, 0.0, 0, 0}};
22594
22595 #ifdef __cplusplus
22596 }
22597 #endif
22598 /* -----------------------------------------------------------------------------
22599 * Type initialization:
22600 * This problem is tough by the requirement that no dynamic
22601 * memory is used. Also, since swig_type_info structures store pointers to
22602 * swig_cast_info structures and swig_cast_info structures store pointers back
22603 * to swig_type_info structures, we need some lookup code at initialization.
22604 * The idea is that swig generates all the structures that are needed.
22605 * The runtime then collects these partially filled structures.
22606 * The SWIG_InitializeModule function takes these initial arrays out of
22607 * swig_module, and does all the lookup, filling in the swig_module.types
22608 * array with the correct data and linking the correct swig_cast_info
22609 * structures together.
22610 *
22611 * The generated swig_type_info structures are assigned staticly to an initial
22612 * array. We just loop though that array, and handle each type individually.
22613 * First we lookup if this type has been already loaded, and if so, use the
22614 * loaded structure instead of the generated one. Then we have to fill in the
22615 * cast linked list. The cast data is initially stored in something like a
22616 * two-dimensional array. Each row corresponds to a type (there are the same
22617 * number of rows as there are in the swig_type_initial array). Each entry in
22618 * a column is one of the swig_cast_info structures for that type.
22619 * The cast_initial array is actually an array of arrays, because each row has
22620 * a variable number of columns. So to actually build the cast linked list,
22621 * we find the array of casts associated with the type, and loop through it
22622 * adding the casts to the list. The one last trick we need to do is making
22623 * sure the type pointer in the swig_cast_info struct is correct.
22624 *
22625 * First off, we lookup the cast->type name to see if it is already loaded.
22626 * There are three cases to handle:
22627 * 1) If the cast->type has already been loaded AND the type we are adding
22628 * casting info to has not been loaded (it is in this module), THEN we
22629 * replace the cast->type pointer with the type pointer that has already
22630 * been loaded.
22631 * 2) If BOTH types (the one we are adding casting info to, and the
22632 * cast->type) are loaded, THEN the cast info has already been loaded by
22633 * the previous module so we just ignore it.
22634 * 3) Finally, if cast->type has not already been loaded, then we add that
22635 * swig_cast_info to the linked list (because the cast->type) pointer will
22636 * be correct.
22637 * ----------------------------------------------------------------------------- */
22638
22639 #ifdef __cplusplus
22640 extern "C" {
22641 #if 0
22642 } /* c-mode */
22643 #endif
22644 #endif
22645
22646 #if 0
22647 #define SWIGRUNTIME_DEBUG
22648 #endif
22649
22650 SWIGRUNTIME void
22651 SWIG_InitializeModule(void *clientdata) {
22652 size_t i;
22653 swig_module_info *module_head;
22654 static int init_run = 0;
22655
22656 clientdata = clientdata;
22657
22658 if (init_run) return;
22659 init_run = 1;
22660
22661 /* Initialize the swig_module */
22662 swig_module.type_initial = swig_type_initial;
22663 swig_module.cast_initial = swig_cast_initial;
22664
22665 /* Try and load any already created modules */
22666 module_head = SWIG_GetModule(clientdata);
22667 if (module_head) {
22668 swig_module.next = module_head->next;
22669 module_head->next = &swig_module;
22670 } else {
22671 /* This is the first module loaded */
22672 swig_module.next = &swig_module;
22673 SWIG_SetModule(clientdata, &swig_module);
22674 }
22675
22676 /* Now work on filling in swig_module.types */
22677 #ifdef SWIGRUNTIME_DEBUG
22678 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22679 #endif
22680 for (i = 0; i < swig_module.size; ++i) {
22681 swig_type_info *type = 0;
22682 swig_type_info *ret;
22683 swig_cast_info *cast;
22684
22685 #ifdef SWIGRUNTIME_DEBUG
22686 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22687 #endif
22688
22689 /* if there is another module already loaded */
22690 if (swig_module.next != &swig_module) {
22691 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22692 }
22693 if (type) {
22694 /* Overwrite clientdata field */
22695 #ifdef SWIGRUNTIME_DEBUG
22696 printf("SWIG_InitializeModule: found type %s\n", type->name);
22697 #endif
22698 if (swig_module.type_initial[i]->clientdata) {
22699 type->clientdata = swig_module.type_initial[i]->clientdata;
22700 #ifdef SWIGRUNTIME_DEBUG
22701 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22702 #endif
22703 }
22704 } else {
22705 type = swig_module.type_initial[i];
22706 }
22707
22708 /* Insert casting types */
22709 cast = swig_module.cast_initial[i];
22710 while (cast->type) {
22711 /* Don't need to add information already in the list */
22712 ret = 0;
22713 #ifdef SWIGRUNTIME_DEBUG
22714 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22715 #endif
22716 if (swig_module.next != &swig_module) {
22717 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22718 #ifdef SWIGRUNTIME_DEBUG
22719 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22720 #endif
22721 }
22722 if (ret) {
22723 if (type == swig_module.type_initial[i]) {
22724 #ifdef SWIGRUNTIME_DEBUG
22725 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22726 #endif
22727 cast->type = ret;
22728 ret = 0;
22729 } else {
22730 /* Check for casting already in the list */
22731 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22732 #ifdef SWIGRUNTIME_DEBUG
22733 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22734 #endif
22735 if (!ocast) ret = 0;
22736 }
22737 }
22738
22739 if (!ret) {
22740 #ifdef SWIGRUNTIME_DEBUG
22741 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22742 #endif
22743 if (type->cast) {
22744 type->cast->prev = cast;
22745 cast->next = type->cast;
22746 }
22747 type->cast = cast;
22748 }
22749 cast++;
22750 }
22751 /* Set entry in modules->types array equal to the type */
22752 swig_module.types[i] = type;
22753 }
22754 swig_module.types[i] = 0;
22755
22756 #ifdef SWIGRUNTIME_DEBUG
22757 printf("**** SWIG_InitializeModule: Cast List ******\n");
22758 for (i = 0; i < swig_module.size; ++i) {
22759 int j = 0;
22760 swig_cast_info *cast = swig_module.cast_initial[i];
22761 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22762 while (cast->type) {
22763 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22764 cast++;
22765 ++j;
22766 }
22767 printf("---- Total casts: %d\n",j);
22768 }
22769 printf("**** SWIG_InitializeModule: Cast List ******\n");
22770 #endif
22771 }
22772
22773 /* This function will propagate the clientdata field of type to
22774 * any new swig_type_info structures that have been added into the list
22775 * of equivalent types. It is like calling
22776 * SWIG_TypeClientData(type, clientdata) a second time.
22777 */
22778 SWIGRUNTIME void
22779 SWIG_PropagateClientData(void) {
22780 size_t i;
22781 swig_cast_info *equiv;
22782 static int init_run = 0;
22783
22784 if (init_run) return;
22785 init_run = 1;
22786
22787 for (i = 0; i < swig_module.size; i++) {
22788 if (swig_module.types[i]->clientdata) {
22789 equiv = swig_module.types[i]->cast;
22790 while (equiv) {
22791 if (!equiv->converter) {
22792 if (equiv->type && !equiv->type->clientdata)
22793 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22794 }
22795 equiv = equiv->next;
22796 }
22797 }
22798 }
22799 }
22800
22801 #ifdef __cplusplus
22802 #if 0
22803 {
22804 /* c-mode */
22805 #endif
22806 }
22807 #endif
22808
22809
22810
22811 #ifdef __cplusplus
22812 extern "C" {
22813 #endif
22814
22815 /* Python-specific SWIG API */
22816 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22817 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22818 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22819
22820 /* -----------------------------------------------------------------------------
22821 * global variable support code.
22822 * ----------------------------------------------------------------------------- */
22823
22824 typedef struct swig_globalvar {
22825 char *name; /* Name of global variable */
22826 PyObject *(*get_attr)(void); /* Return the current value */
22827 int (*set_attr)(PyObject *); /* Set the value */
22828 struct swig_globalvar *next;
22829 } swig_globalvar;
22830
22831 typedef struct swig_varlinkobject {
22832 PyObject_HEAD
22833 swig_globalvar *vars;
22834 } swig_varlinkobject;
22835
22836 SWIGINTERN PyObject *
22837 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22838 return PyString_FromString("<Swig global variables>");
22839 }
22840
22841 SWIGINTERN PyObject *
22842 swig_varlink_str(swig_varlinkobject *v) {
22843 PyObject *str = PyString_FromString("(");
22844 swig_globalvar *var;
22845 for (var = v->vars; var; var=var->next) {
22846 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22847 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22848 }
22849 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22850 return str;
22851 }
22852
22853 SWIGINTERN int
22854 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22855 PyObject *str = swig_varlink_str(v);
22856 fprintf(fp,"Swig global variables ");
22857 fprintf(fp,"%s\n", PyString_AsString(str));
22858 Py_DECREF(str);
22859 return 0;
22860 }
22861
22862 SWIGINTERN void
22863 swig_varlink_dealloc(swig_varlinkobject *v) {
22864 swig_globalvar *var = v->vars;
22865 while (var) {
22866 swig_globalvar *n = var->next;
22867 free(var->name);
22868 free(var);
22869 var = n;
22870 }
22871 }
22872
22873 SWIGINTERN PyObject *
22874 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22875 PyObject *res = NULL;
22876 swig_globalvar *var = v->vars;
22877 while (var) {
22878 if (strcmp(var->name,n) == 0) {
22879 res = (*var->get_attr)();
22880 break;
22881 }
22882 var = var->next;
22883 }
22884 if (res == NULL && !PyErr_Occurred()) {
22885 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22886 }
22887 return res;
22888 }
22889
22890 SWIGINTERN int
22891 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22892 int res = 1;
22893 swig_globalvar *var = v->vars;
22894 while (var) {
22895 if (strcmp(var->name,n) == 0) {
22896 res = (*var->set_attr)(p);
22897 break;
22898 }
22899 var = var->next;
22900 }
22901 if (res == 1 && !PyErr_Occurred()) {
22902 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22903 }
22904 return res;
22905 }
22906
22907 SWIGINTERN PyTypeObject*
22908 swig_varlink_type(void) {
22909 static char varlink__doc__[] = "Swig var link object";
22910 static PyTypeObject varlink_type;
22911 static int type_init = 0;
22912 if (!type_init) {
22913 const PyTypeObject tmp
22914 = {
22915 PyObject_HEAD_INIT(NULL)
22916 0, /* Number of items in variable part (ob_size) */
22917 (char *)"swigvarlink", /* Type name (tp_name) */
22918 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22919 0, /* Itemsize (tp_itemsize) */
22920 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
22921 (printfunc) swig_varlink_print, /* Print (tp_print) */
22922 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22923 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22924 0, /* tp_compare */
22925 (reprfunc) swig_varlink_repr, /* tp_repr */
22926 0, /* tp_as_number */
22927 0, /* tp_as_sequence */
22928 0, /* tp_as_mapping */
22929 0, /* tp_hash */
22930 0, /* tp_call */
22931 (reprfunc)swig_varlink_str, /* tp_str */
22932 0, /* tp_getattro */
22933 0, /* tp_setattro */
22934 0, /* tp_as_buffer */
22935 0, /* tp_flags */
22936 varlink__doc__, /* tp_doc */
22937 0, /* tp_traverse */
22938 0, /* tp_clear */
22939 0, /* tp_richcompare */
22940 0, /* tp_weaklistoffset */
22941 #if PY_VERSION_HEX >= 0x02020000
22942 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22943 #endif
22944 #if PY_VERSION_HEX >= 0x02030000
22945 0, /* tp_del */
22946 #endif
22947 #ifdef COUNT_ALLOCS
22948 0,0,0,0 /* tp_alloc -> tp_next */
22949 #endif
22950 };
22951 varlink_type = tmp;
22952 varlink_type.ob_type = &PyType_Type;
22953 type_init = 1;
22954 }
22955 return &varlink_type;
22956 }
22957
22958 /* Create a variable linking object for use later */
22959 SWIGINTERN PyObject *
22960 SWIG_Python_newvarlink(void) {
22961 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22962 if (result) {
22963 result->vars = 0;
22964 }
22965 return ((PyObject*) result);
22966 }
22967
22968 SWIGINTERN void
22969 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22970 swig_varlinkobject *v = (swig_varlinkobject *) p;
22971 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22972 if (gv) {
22973 size_t size = strlen(name)+1;
22974 gv->name = (char *)malloc(size);
22975 if (gv->name) {
22976 strncpy(gv->name,name,size);
22977 gv->get_attr = get_attr;
22978 gv->set_attr = set_attr;
22979 gv->next = v->vars;
22980 }
22981 }
22982 v->vars = gv;
22983 }
22984
22985 SWIGINTERN PyObject *
22986 SWIG_globals() {
22987 static PyObject *_SWIG_globals = 0;
22988 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
22989 return _SWIG_globals;
22990 }
22991
22992 /* -----------------------------------------------------------------------------
22993 * constants/methods manipulation
22994 * ----------------------------------------------------------------------------- */
22995
22996 /* Install Constants */
22997 SWIGINTERN void
22998 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22999 PyObject *obj = 0;
23000 size_t i;
23001 for (i = 0; constants[i].type; ++i) {
23002 switch(constants[i].type) {
23003 case SWIG_PY_POINTER:
23004 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23005 break;
23006 case SWIG_PY_BINARY:
23007 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23008 break;
23009 default:
23010 obj = 0;
23011 break;
23012 }
23013 if (obj) {
23014 PyDict_SetItemString(d, constants[i].name, obj);
23015 Py_DECREF(obj);
23016 }
23017 }
23018 }
23019
23020 /* -----------------------------------------------------------------------------*/
23021 /* Fix SwigMethods to carry the callback ptrs when needed */
23022 /* -----------------------------------------------------------------------------*/
23023
23024 SWIGINTERN void
23025 SWIG_Python_FixMethods(PyMethodDef *methods,
23026 swig_const_info *const_table,
23027 swig_type_info **types,
23028 swig_type_info **types_initial) {
23029 size_t i;
23030 for (i = 0; methods[i].ml_name; ++i) {
23031 const char *c = methods[i].ml_doc;
23032 if (c && (c = strstr(c, "swig_ptr: "))) {
23033 int j;
23034 swig_const_info *ci = 0;
23035 const char *name = c + 10;
23036 for (j = 0; const_table[j].type; ++j) {
23037 if (strncmp(const_table[j].name, name,
23038 strlen(const_table[j].name)) == 0) {
23039 ci = &(const_table[j]);
23040 break;
23041 }
23042 }
23043 if (ci) {
23044 size_t shift = (ci->ptype) - types;
23045 swig_type_info *ty = types_initial[shift];
23046 size_t ldoc = (c - methods[i].ml_doc);
23047 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23048 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23049 if (ndoc) {
23050 char *buff = ndoc;
23051 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23052 if (ptr) {
23053 strncpy(buff, methods[i].ml_doc, ldoc);
23054 buff += ldoc;
23055 strncpy(buff, "swig_ptr: ", 10);
23056 buff += 10;
23057 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23058 methods[i].ml_doc = ndoc;
23059 }
23060 }
23061 }
23062 }
23063 }
23064 }
23065
23066 #ifdef __cplusplus
23067 }
23068 #endif
23069
23070 /* -----------------------------------------------------------------------------*
23071 * Partial Init method
23072 * -----------------------------------------------------------------------------*/
23073
23074 #ifdef __cplusplus
23075 extern "C"
23076 #endif
23077 SWIGEXPORT void SWIG_init(void) {
23078 PyObject *m, *d;
23079
23080 /* Fix SwigMethods to carry the callback ptrs when needed */
23081 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23082
23083 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23084 d = PyModule_GetDict(m);
23085
23086 SWIG_InitializeModule(0);
23087 SWIG_InstallConstants(d,swig_const_table);
23088
23089
23090 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23091 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23092 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23093 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23094 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23095 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23096 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23097 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23098 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23099 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23100 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23101 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23102 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23103 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23104 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23105 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23106 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23107 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23108 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23109 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23110 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23111 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23112 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23113 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23114 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23115 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23116 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23117 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23118 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23119 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23120 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23121 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23122 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23123 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23124 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23125 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23126 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23127 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23128 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23129 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23130 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23131 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23132 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23133 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23134 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23135 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23136 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23137 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23138 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23139 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23140 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23141 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23142 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23143 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23144 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23145 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23146
23147
23148 }
23149
wxWidgets (Impactor)