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


e30f7c5a3c015bb6f420f118cfbeb4e567cba048
[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_wxNumberEntryDialog swig_types[107]
2574 #define SWIGTYPE_p_wxObject swig_types[108]
2575 #define SWIGTYPE_p_wxPCXHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNGHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNMHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPageSetupDialog swig_types[112]
2579 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[113]
2580 #define SWIGTYPE_p_wxPaintEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPanel swig_types[116]
2583 #define SWIGTYPE_p_wxPaperSize swig_types[117]
2584 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[118]
2585 #define SWIGTYPE_p_wxPen swig_types[119]
2586 #define SWIGTYPE_p_wxPoint swig_types[120]
2587 #define SWIGTYPE_p_wxPopupWindow swig_types[121]
2588 #define SWIGTYPE_p_wxPreviewCanvas swig_types[122]
2589 #define SWIGTYPE_p_wxPreviewControlBar swig_types[123]
2590 #define SWIGTYPE_p_wxPreviewFrame swig_types[124]
2591 #define SWIGTYPE_p_wxPrintData swig_types[125]
2592 #define SWIGTYPE_p_wxPrintDialog swig_types[126]
2593 #define SWIGTYPE_p_wxPrintDialogData swig_types[127]
2594 #define SWIGTYPE_p_wxPrintPreview swig_types[128]
2595 #define SWIGTYPE_p_wxPrinter swig_types[129]
2596 #define SWIGTYPE_p_wxProgressDialog swig_types[130]
2597 #define SWIGTYPE_p_wxPyApp swig_types[131]
2598 #define SWIGTYPE_p_wxPyCommandEvent swig_types[132]
2599 #define SWIGTYPE_p_wxPyEvent swig_types[133]
2600 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[135]
2602 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridTableBase swig_types[137]
2604 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[138]
2605 #define SWIGTYPE_p_wxPyImageHandler swig_types[139]
2606 #define SWIGTYPE_p_wxPyPanel swig_types[140]
2607 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[141]
2608 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[142]
2609 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[143]
2610 #define SWIGTYPE_p_wxPyPrintPreview swig_types[144]
2611 #define SWIGTYPE_p_wxPyPrintout swig_types[145]
2612 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[146]
2613 #define SWIGTYPE_p_wxPySizer swig_types[147]
2614 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[148]
2615 #define SWIGTYPE_p_wxPyVListBox swig_types[149]
2616 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[150]
2617 #define SWIGTYPE_p_wxPyValidator swig_types[151]
2618 #define SWIGTYPE_p_wxPyWindow swig_types[152]
2619 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[153]
2620 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[154]
2621 #define SWIGTYPE_p_wxRect swig_types[155]
2622 #define SWIGTYPE_p_wxSashEvent swig_types[156]
2623 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[157]
2624 #define SWIGTYPE_p_wxSashWindow swig_types[158]
2625 #define SWIGTYPE_p_wxScrollEvent swig_types[159]
2626 #define SWIGTYPE_p_wxScrollWinEvent swig_types[160]
2627 #define SWIGTYPE_p_wxScrolledWindow swig_types[161]
2628 #define SWIGTYPE_p_wxSetCursorEvent swig_types[162]
2629 #define SWIGTYPE_p_wxShowEvent swig_types[163]
2630 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[164]
2631 #define SWIGTYPE_p_wxSizeEvent swig_types[165]
2632 #define SWIGTYPE_p_wxSizer swig_types[166]
2633 #define SWIGTYPE_p_wxSizerItem swig_types[167]
2634 #define SWIGTYPE_p_wxSplashScreen swig_types[168]
2635 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[169]
2636 #define SWIGTYPE_p_wxSplitterEvent swig_types[170]
2637 #define SWIGTYPE_p_wxSplitterWindow swig_types[171]
2638 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[172]
2639 #define SWIGTYPE_p_wxStatusBar swig_types[173]
2640 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[174]
2641 #define SWIGTYPE_p_wxString swig_types[175]
2642 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[176]
2643 #define SWIGTYPE_p_wxTIFFHandler swig_types[177]
2644 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[178]
2645 #define SWIGTYPE_p_wxTextEntryDialog swig_types[179]
2646 #define SWIGTYPE_p_wxTipWindow swig_types[180]
2647 #define SWIGTYPE_p_wxTopLevelWindow swig_types[181]
2648 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[182]
2649 #define SWIGTYPE_p_wxValidator swig_types[183]
2650 #define SWIGTYPE_p_wxVisualAttributes swig_types[184]
2651 #define SWIGTYPE_p_wxWindow swig_types[185]
2652 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[186]
2653 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[187]
2654 #define SWIGTYPE_p_wxXPMHandler swig_types[188]
2655 static swig_type_info *swig_types[190];
2656 static swig_module_info swig_module = {swig_types, 189, 0, 0, 0, 0};
2657 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2658 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2659
2660 /* -------- TYPES TABLE (END) -------- */
2661
2662 #if (PY_VERSION_HEX <= 0x02000000)
2663 # if !defined(SWIG_PYTHON_CLASSIC)
2664 # error "This python version requires to use swig with the '-classic' option"
2665 # endif
2666 #endif
2667 #if (PY_VERSION_HEX <= 0x02020000)
2668 # error "This python version requires to use swig with the '-nomodern' option"
2669 #endif
2670 #if (PY_VERSION_HEX <= 0x02020000)
2671 # error "This python version requires to use swig with the '-nomodernargs' option"
2672 #endif
2673 #ifndef METH_O
2674 # error "This python version requires to use swig with the '-nofastunpack' option"
2675 #endif
2676
2677 /*-----------------------------------------------
2678 @(target):= _grid.so
2679 ------------------------------------------------*/
2680 #define SWIG_init init_grid
2681
2682 #define SWIG_name "_grid"
2683
2684 #define SWIGVERSION 0x010329
2685
2686
2687 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2688 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2689
2690
2691 #include <stdexcept>
2692
2693
2694 namespace swig {
2695 class PyObject_ptr {
2696 protected:
2697 PyObject *_obj;
2698
2699 public:
2700 PyObject_ptr() :_obj(0)
2701 {
2702 }
2703
2704 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2705 {
2706 Py_XINCREF(_obj);
2707 }
2708
2709 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2710 {
2711 if (initial_ref) Py_XINCREF(_obj);
2712 }
2713
2714 PyObject_ptr & operator=(const PyObject_ptr& item)
2715 {
2716 Py_XINCREF(item._obj);
2717 Py_XDECREF(_obj);
2718 _obj = item._obj;
2719 return *this;
2720 }
2721
2722 ~PyObject_ptr()
2723 {
2724 Py_XDECREF(_obj);
2725 }
2726
2727 operator PyObject *() const
2728 {
2729 return _obj;
2730 }
2731
2732 PyObject *operator->() const
2733 {
2734 return _obj;
2735 }
2736 };
2737 }
2738
2739
2740 namespace swig {
2741 struct PyObject_var : PyObject_ptr {
2742 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2743
2744 PyObject_var & operator = (PyObject* obj)
2745 {
2746 Py_XDECREF(_obj);
2747 _obj = obj;
2748 return *this;
2749 }
2750 };
2751 }
2752
2753
2754 #include "wx/wxPython/wxPython.h"
2755 #include "wx/wxPython/pyclasses.h"
2756 #include "wx/wxPython/printfw.h"
2757
2758 #include <wx/grid.h>
2759 #include <wx/generic/gridctrl.h>
2760
2761
2762 static const wxString wxPyEmptyString(wxEmptyString);
2763 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2764 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2765
2766
2767 #define wxPyMake_TEMPLATE(TYPE) \
2768 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2769 PyObject* target = NULL; \
2770 if (source) { \
2771 /* Check if there is already a pointer to a Python object in the \
2772 OOR data that we can use. */ \
2773 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2774 if (data) { \
2775 target = data->m_obj; \
2776 if (target) \
2777 Py_INCREF(target); \
2778 } \
2779 /* Otherwise make a new wrapper for it the old fashioned way and \
2780 give it the OOR treatment */ \
2781 if (! target) { \
2782 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2783 if (target) \
2784 source->SetClientObject(new wxPyOORClientData(target)); \
2785 } \
2786 } else { /* source was NULL so return None. */ \
2787 Py_INCREF(Py_None); target = Py_None; \
2788 } \
2789 return target; \
2790 } \
2791
2792
2793 wxPyMake_TEMPLATE(wxGridCellRenderer)
2794 wxPyMake_TEMPLATE(wxGridCellEditor)
2795 wxPyMake_TEMPLATE(wxGridCellAttr)
2796 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2797 wxPyMake_TEMPLATE(wxGridTableBase)
2798
2799
2800
2801 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2802 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2803 wxGridCellAttr* rval = NULL; \
2804 bool found; \
2805 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2806 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2807 PyObject* ro; \
2808 wxGridCellAttr* ptr; \
2809 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2810 if (ro) { \
2811 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2812 rval = ptr; \
2813 Py_DECREF(ro); \
2814 } \
2815 } \
2816 wxPyEndBlockThreads(blocked); \
2817 if (! found) \
2818 rval = PCLASS::CBNAME(a, b, c); \
2819 return rval; \
2820 }
2821
2822
2823 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2824 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2825 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2826 bool found; \
2827 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2828 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2829 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2830 Py_DECREF(obj); \
2831 } \
2832 wxPyEndBlockThreads(blocked); \
2833 if (! found) \
2834 PCLASS::CBNAME(attr, a, b); \
2835 }
2836
2837
2838
2839 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2840 void CBNAME(wxGridCellAttr *attr, int val) { \
2841 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2842 bool found; \
2843 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2844 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2845 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2846 Py_DECREF(obj); \
2847 } \
2848 wxPyEndBlockThreads(blocked); \
2849 if (! found) \
2850 PCLASS::CBNAME(attr, val); \
2851 }
2852
2853
2854
2855 #define PYCALLBACK_INT__pure(CBNAME) \
2856 int CBNAME() { \
2857 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2858 int rval = 0; \
2859 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2860 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2861 wxPyEndBlockThreads(blocked); \
2862 return rval; \
2863 }
2864
2865
2866
2867 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2868 bool CBNAME(int a, int b) { \
2869 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2870 bool rval = 0; \
2871 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2872 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2873 wxPyEndBlockThreads(blocked); \
2874 return rval; \
2875 }
2876
2877
2878 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2879 wxString CBNAME(int a, int b) { \
2880 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2881 wxString rval; \
2882 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2883 PyObject* ro; \
2884 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2885 if (ro) { \
2886 rval = Py2wxString(ro); \
2887 Py_DECREF(ro); \
2888 } \
2889 } \
2890 wxPyEndBlockThreads(blocked); \
2891 return rval; \
2892 }
2893
2894
2895 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2896 void CBNAME(int a, int b, const wxString& c) { \
2897 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2898 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2899 PyObject* s = wx2PyString(c); \
2900 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2901 Py_DECREF(s); \
2902 } \
2903 wxPyEndBlockThreads(blocked); \
2904 }
2905
2906
2907 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2908 wxString CBNAME(int a, int b) { \
2909 bool found; \
2910 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2911 wxString rval; \
2912 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2913 PyObject* ro; \
2914 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2915 if (ro) { \
2916 rval = Py2wxString(ro); \
2917 Py_DECREF(ro); \
2918 } \
2919 } \
2920 wxPyEndBlockThreads(blocked); \
2921 if (! found) \
2922 rval = PCLASS::CBNAME(a, b); \
2923 return rval; \
2924 }
2925
2926
2927 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2928 bool CBNAME(int a, int b, const wxString& c) { \
2929 bool rval = 0; \
2930 bool found; \
2931 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2932 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2933 PyObject* s = wx2PyString(c); \
2934 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2935 Py_DECREF(s); \
2936 } \
2937 wxPyEndBlockThreads(blocked); \
2938 if (! found) \
2939 rval = PCLASS::CBNAME(a,b,c); \
2940 return rval; \
2941 }
2942
2943
2944
2945
2946 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2947 long CBNAME(int a, int b) { \
2948 long rval; \
2949 bool found; \
2950 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2951 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2952 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2953 wxPyEndBlockThreads(blocked); \
2954 if (! found) \
2955 rval = PCLASS::CBNAME(a,b); \
2956 return rval; \
2957 }
2958
2959
2960 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2961 bool CBNAME(int a, int b) { \
2962 bool rval = 0; \
2963 bool found; \
2964 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2965 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2966 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2967 wxPyEndBlockThreads(blocked); \
2968 if (! found) \
2969 rval = PCLASS::CBNAME(a,b); \
2970 return rval; \
2971 }
2972
2973
2974
2975 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2976 double CBNAME(int a, int b) { \
2977 bool found; \
2978 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2979 double rval; \
2980 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2981 PyObject* ro; \
2982 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2983 if (ro) { \
2984 PyObject* str = PyObject_Str(ro); \
2985 rval = PyFloat_AsDouble(str); \
2986 Py_DECREF(ro); Py_DECREF(str); \
2987 } \
2988 } \
2989 wxPyEndBlockThreads(blocked); \
2990 if (! found) \
2991 rval = PCLASS::CBNAME(a, b); \
2992 return rval; \
2993 }
2994
2995
2996
2997 #define PYCALLBACK__(PCLASS, CBNAME) \
2998 void CBNAME() { \
2999 bool found; \
3000 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3001 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3002 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3003 wxPyEndBlockThreads(blocked); \
3004 if (! found) \
3005 PCLASS::CBNAME(); \
3006 }
3007
3008
3009
3010 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3011 bool CBNAME(size_t a, size_t b) { \
3012 bool rval = 0; \
3013 bool found; \
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3015 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3016 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3017 wxPyEndBlockThreads(blocked); \
3018 if (! found) \
3019 rval = PCLASS::CBNAME(a,b); \
3020 return rval; \
3021 }
3022
3023
3024
3025 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3026 bool CBNAME(size_t a) { \
3027 bool rval = 0; \
3028 bool found; \
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3030 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3031 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3032 wxPyEndBlockThreads(blocked); \
3033 if (! found) \
3034 rval = PCLASS::CBNAME(a); \
3035 return rval; \
3036 }
3037
3038
3039 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3040 wxString CBNAME(int a) { \
3041 bool found; \
3042 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3043 wxString rval; \
3044 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3045 PyObject* ro; \
3046 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3047 if (ro) { \
3048 rval = Py2wxString(ro); \
3049 Py_DECREF(ro); \
3050 } \
3051 } \
3052 wxPyEndBlockThreads(blocked); \
3053 if (! found) \
3054 rval = PCLASS::CBNAME(a); \
3055 return rval; \
3056 }
3057
3058
3059 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3060 void CBNAME(int a, const wxString& c) { \
3061 bool found; \
3062 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3063 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3064 PyObject* s = wx2PyString(c); \
3065 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3066 Py_DECREF(s); \
3067 } \
3068 wxPyEndBlockThreads(blocked); \
3069 if (! found) \
3070 PCLASS::CBNAME(a,c); \
3071 }
3072
3073
3074
3075
3076 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3077 bool CBNAME() { \
3078 bool rval = 0; \
3079 bool found; \
3080 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3081 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3082 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3083 wxPyEndBlockThreads(blocked); \
3084 if (! found) \
3085 rval = PCLASS::CBNAME(); \
3086 return rval; \
3087 }
3088
3089
3090
3091 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3092 void CBNAME(size_t a, int b) { \
3093 bool found; \
3094 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3095 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3096 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3097 wxPyEndBlockThreads(blocked); \
3098 if (! found) \
3099 PCLASS::CBNAME(a,b); \
3100 }
3101
3102
3103
3104
3105 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3106 void CBNAME(int a, int b, long c) { \
3107 bool found; \
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3109 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3110 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3111 wxPyEndBlockThreads(blocked); \
3112 if (! found) \
3113 PCLASS::CBNAME(a,b,c); \
3114 }
3115
3116
3117
3118
3119 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3120 void CBNAME(int a, int b, double c) { \
3121 bool found; \
3122 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3123 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3124 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3125 wxPyEndBlockThreads(blocked); \
3126 if (! found) \
3127 PCLASS::CBNAME(a,b,c); \
3128 }
3129
3130
3131
3132 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3133 void CBNAME(int a, int b, bool c) { \
3134 bool found; \
3135 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3136 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3137 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3138 wxPyEndBlockThreads(blocked); \
3139 if (! found) \
3140 PCLASS::CBNAME(a,b,c); \
3141 }
3142
3143
3144
3145
3146
3147 SWIGINTERN swig_type_info*
3148 SWIG_pchar_descriptor()
3149 {
3150 static int init = 0;
3151 static swig_type_info* info = 0;
3152 if (!init) {
3153 info = SWIG_TypeQuery("_p_char");
3154 init = 1;
3155 }
3156 return info;
3157 }
3158
3159
3160 SWIGINTERNINLINE PyObject *
3161 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3162 {
3163 if (carray) {
3164 if (size > INT_MAX) {
3165 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3166 return pchar_descriptor ?
3167 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3168 } else {
3169 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3170 }
3171 } else {
3172 return SWIG_Py_Void();
3173 }
3174 }
3175
3176
3177 SWIGINTERNINLINE PyObject *
3178 SWIG_FromCharPtr(const char *cptr)
3179 {
3180 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3181 }
3182
3183
3184 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3185 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3186 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3187 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3188 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3189 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3190 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3191 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3192 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3193 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3194
3195
3196 #define SWIG_From_long PyInt_FromLong
3197
3198
3199 SWIGINTERNINLINE PyObject *
3200 SWIG_From_int (int value)
3201 {
3202 return SWIG_From_long (value);
3203 }
3204
3205 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3206 if (!self->GetClientObject())
3207 self->SetClientObject(new wxPyOORClientData(_self));
3208 }
3209 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3210 }
3211
3212 class wxPyGridCellRenderer : public wxGridCellRenderer
3213 {
3214 public:
3215 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3216
3217 // Implement Python callback aware virtual methods
3218 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3219 wxDC& dc, const wxRect& rect,
3220 int row, int col, bool isSelected) {
3221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3222 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3223 PyObject* go = wxPyMake_wxObject(&grid,false);
3224 PyObject* dco = wxPyMake_wxObject(&dc,false);
3225 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3226 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3227
3228 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3229 row, col, isSelected));
3230 Py_DECREF(go);
3231 Py_DECREF(ao);
3232 Py_DECREF(dco);
3233 Py_DECREF(ro);
3234 }
3235 wxPyEndBlockThreads(blocked);
3236 }
3237
3238 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3239 int row, int col) {
3240 wxSize rval;
3241 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3242 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3243 PyObject* ro;
3244 wxSize* ptr;
3245 PyObject* go = wxPyMake_wxObject(&grid,false);
3246 PyObject* dco = wxPyMake_wxObject(&dc,false);
3247 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3248
3249 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3250 go, ao, dco,
3251 row, col));
3252 Py_DECREF(go);
3253 Py_DECREF(ao);
3254 Py_DECREF(dco);
3255
3256 if (ro) {
3257 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3258 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3259 rval = *ptr;
3260 }
3261 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3262 PyObject* o1 = PySequence_GetItem(ro, 0);
3263 PyObject* o2 = PySequence_GetItem(ro, 1);
3264 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3265 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3266 else
3267 PyErr_SetString(PyExc_TypeError, errmsg);
3268 Py_DECREF(o1);
3269 Py_DECREF(o2);
3270 }
3271 else {
3272 PyErr_SetString(PyExc_TypeError, errmsg);
3273 }
3274 Py_DECREF(ro);
3275 }
3276 }
3277 wxPyEndBlockThreads(blocked);
3278 return rval;
3279 }
3280
3281
3282 wxGridCellRenderer *Clone() const {
3283 wxGridCellRenderer* rval = NULL;
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3286 PyObject* ro;
3287 wxGridCellRenderer* ptr;
3288 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3289 if (ro) {
3290 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3291 rval = ptr;
3292 Py_DECREF(ro);
3293 }
3294 }
3295 wxPyEndBlockThreads(blocked);
3296 return rval;
3297 }
3298
3299 DEC_PYCALLBACK__STRING(SetParameters);
3300
3301 PYPRIVATE;
3302 };
3303
3304 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3305
3306
3307
3308 #include <limits.h>
3309 #ifndef LLONG_MIN
3310 # define LLONG_MIN LONG_LONG_MIN
3311 #endif
3312 #ifndef LLONG_MAX
3313 # define LLONG_MAX LONG_LONG_MAX
3314 #endif
3315 #ifndef ULLONG_MAX
3316 # define ULLONG_MAX ULONG_LONG_MAX
3317 #endif
3318
3319
3320 SWIGINTERN int
3321 SWIG_AsVal_long (PyObject* obj, long* val)
3322 {
3323 if (PyNumber_Check(obj)) {
3324 if (val) *val = PyInt_AsLong(obj);
3325 return SWIG_OK;
3326 }
3327 return SWIG_TypeError;
3328 }
3329
3330
3331 SWIGINTERN int
3332 SWIG_AsVal_int (PyObject * obj, int *val)
3333 {
3334 long v;
3335 int res = SWIG_AsVal_long (obj, &v);
3336 if (SWIG_IsOK(res)) {
3337 if ((v < INT_MIN || v > INT_MAX)) {
3338 return SWIG_OverflowError;
3339 } else {
3340 if (val) *val = static_cast< int >(v);
3341 }
3342 }
3343 return res;
3344 }
3345
3346
3347 SWIGINTERN int
3348 SWIG_AsVal_bool (PyObject *obj, bool *val)
3349 {
3350 if (obj == Py_True) {
3351 if (val) *val = true;
3352 return SWIG_OK;
3353 } else if (obj == Py_False) {
3354 if (val) *val = false;
3355 return SWIG_OK;
3356 } else {
3357 long v = 0;
3358 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3359 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3360 return res;
3361 }
3362 }
3363
3364
3365 class wxPyGridCellEditor : public wxGridCellEditor
3366 {
3367 public:
3368 wxPyGridCellEditor() : wxGridCellEditor() {}
3369
3370 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3372 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3373 PyObject* po = wxPyMake_wxObject(parent,false);
3374 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3375
3376 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3377 Py_DECREF(po);
3378 Py_DECREF(eo);
3379 }
3380 wxPyEndBlockThreads(blocked);
3381 }
3382
3383
3384 void BeginEdit(int row, int col, wxGrid* grid) {
3385 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3386 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3387 PyObject* go = wxPyMake_wxObject(grid,false);
3388 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3389 Py_DECREF(go);
3390 }
3391 wxPyEndBlockThreads(blocked);
3392 }
3393
3394
3395 bool EndEdit(int row, int col, wxGrid* grid) {
3396 bool rv = false;
3397 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3398 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3399 PyObject* go = wxPyMake_wxObject(grid,false);
3400 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3401 Py_DECREF(go);
3402 }
3403 wxPyEndBlockThreads(blocked);
3404 return rv;
3405 }
3406
3407
3408 wxGridCellEditor* Clone() const {
3409 wxGridCellEditor* rval = NULL;
3410 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3411 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3412 PyObject* ro;
3413 wxGridCellEditor* ptr;
3414 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3415 if (ro) {
3416 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3417 rval = ptr;
3418 Py_DECREF(ro);
3419 }
3420 }
3421 wxPyEndBlockThreads(blocked);
3422 return rval;
3423 }
3424
3425
3426 void Show(bool show, wxGridCellAttr *attr) {
3427 bool found;
3428 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3429 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3430 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3431 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3432 Py_DECREF(ao);
3433 }
3434 wxPyEndBlockThreads(blocked);
3435 if (! found)
3436 wxGridCellEditor::Show(show, attr);
3437 }
3438
3439
3440 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3441 bool found;
3442 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3443 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3444 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3445 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3446
3447 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3448
3449 Py_DECREF(ro);
3450 Py_DECREF(ao);
3451 }
3452 wxPyEndBlockThreads(blocked);
3453 if (! found)
3454 wxGridCellEditor::PaintBackground(rectCell, attr);
3455 }
3456
3457
3458 DEC_PYCALLBACK___pure(Reset);
3459 DEC_PYCALLBACK__constany(SetSize, wxRect);
3460 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3461 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3462 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3463 DEC_PYCALLBACK__(StartingClick);
3464 DEC_PYCALLBACK__(Destroy);
3465 DEC_PYCALLBACK__STRING(SetParameters);
3466 DEC_PYCALLBACK_STRING__constpure(GetValue);
3467
3468 PYPRIVATE;
3469 };
3470
3471
3472 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3473 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3474 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3475 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3476 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3477 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3478 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3479 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3480 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3481
3482
3483 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3484 if (!self->GetClientObject())
3485 self->SetClientObject(new wxPyOORClientData(_self));
3486 }
3487 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3488 }
3489 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3490 if (!self->GetClientObject())
3491 self->SetClientObject(new wxPyOORClientData(_self));
3492 }
3493
3494 SWIGINTERN int
3495 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3496 {
3497 long v = 0;
3498 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3499 return SWIG_TypeError;
3500 }
3501 else if (val)
3502 *val = (unsigned long)v;
3503 return SWIG_OK;
3504 }
3505
3506
3507 SWIGINTERNINLINE int
3508 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3509 {
3510 unsigned long v;
3511 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3512 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3513 return res;
3514 }
3515
3516
3517 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3518 {
3519 public:
3520 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3521
3522 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3523 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3524 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3525 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3526
3527 PYPRIVATE;
3528 };
3529
3530 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3531 if (!self->GetClientObject())
3532 self->SetClientObject(new wxPyOORClientData(_self));
3533 }
3534
3535 #define SWIG_From_double PyFloat_FromDouble
3536
3537
3538 SWIGINTERN int
3539 SWIG_AsVal_double (PyObject *obj, double* val)
3540 {
3541 if (PyNumber_Check(obj)) {
3542 if (val) *val = PyFloat_AsDouble(obj);
3543 return SWIG_OK;
3544 }
3545 return SWIG_TypeError;
3546 }
3547
3548
3549 class wxPyGridTableBase : public wxGridTableBase
3550 {
3551 public:
3552 wxPyGridTableBase() : wxGridTableBase() {}
3553
3554 PYCALLBACK_INT__pure(GetNumberRows);
3555 PYCALLBACK_INT__pure(GetNumberCols);
3556 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3557 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3558 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3559 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3560 PYCALLBACK__(wxGridTableBase, Clear);
3561 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3562 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3563 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3564 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3565 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3566 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3567 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3568 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3569 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3570 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3571 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3572 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3573 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3574 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3575 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3576
3577
3578 wxString GetValue(int row, int col) {
3579 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3580 wxString rval;
3581 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3582 PyObject* ro;
3583 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3584 if (ro) {
3585 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3586 PyObject* old = ro;
3587 ro = PyObject_Str(ro);
3588 Py_DECREF(old);
3589 }
3590 rval = Py2wxString(ro);
3591 Py_DECREF(ro);
3592 }
3593 }
3594 wxPyEndBlockThreads(blocked);
3595 return rval;
3596 }
3597
3598 void SetValue(int row, int col, const wxString& val) {
3599 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3600 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3601 PyObject* s = wx2PyString(val);
3602 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3603 Py_DECREF(s);
3604 }
3605 wxPyEndBlockThreads(blocked);
3606 }
3607
3608
3609 // Map the Get/Set methods for the standard non-string types to
3610 // the GetValue and SetValue python methods.
3611 long GetValueAsLong( int row, int col ) {
3612 long rval = 0;
3613 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3614 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3615 PyObject* ro;
3616 PyObject* num;
3617 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3618 if (ro && PyNumber_Check(ro)) {
3619 num = PyNumber_Int(ro);
3620 if (num) {
3621 rval = PyInt_AsLong(num);
3622 Py_DECREF(num);
3623 }
3624 Py_DECREF(ro);
3625 }
3626 }
3627 wxPyEndBlockThreads(blocked);
3628 return rval;
3629 }
3630
3631 double GetValueAsDouble( int row, int col ) {
3632 double rval = 0.0;
3633 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3634 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3635 PyObject* ro;
3636 PyObject* num;
3637 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3638 if (ro && PyNumber_Check(ro)) {
3639 num = PyNumber_Float(ro);
3640 if (num) {
3641 rval = PyFloat_AsDouble(num);
3642 Py_DECREF(num);
3643 }
3644 Py_DECREF(ro);
3645 }
3646 }
3647 wxPyEndBlockThreads(blocked);
3648 return rval;
3649 }
3650
3651 bool GetValueAsBool( int row, int col ) {
3652 return (bool)GetValueAsLong(row, col);
3653 }
3654
3655 void SetValueAsLong( int row, int col, long value ) {
3656 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3657 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3658 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3659 }
3660 wxPyEndBlockThreads(blocked);
3661 }
3662
3663 void SetValueAsDouble( int row, int col, double value ) {
3664 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3665 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3666 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3667 }
3668 wxPyEndBlockThreads(blocked);
3669 }
3670
3671 void SetValueAsBool( int row, int col, bool value ) {
3672 SetValueAsLong( row, col, (long)value );
3673 }
3674
3675
3676 PYPRIVATE;
3677 };
3678
3679 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3680
3681 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3682
3683 if (source == Py_None) {
3684 **obj = wxGridCellCoords(-1,-1);
3685 return true;
3686 }
3687
3688 // If source is an object instance then it may already be the right type
3689 if (wxPySwigInstance_Check(source)) {
3690 wxGridCellCoords* ptr;
3691 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3692 goto error;
3693 *obj = ptr;
3694 return true;
3695 }
3696 // otherwise a 2-tuple of integers is expected
3697 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3698 PyObject* o1 = PySequence_GetItem(source, 0);
3699 PyObject* o2 = PySequence_GetItem(source, 1);
3700 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3701 Py_DECREF(o1);
3702 Py_DECREF(o2);
3703 goto error;
3704 }
3705 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3706 Py_DECREF(o1);
3707 Py_DECREF(o2);
3708 return true;
3709 }
3710
3711 error:
3712 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3713 return false;
3714 }
3715
3716
3717 bool wxGridCellCoords_typecheck(PyObject* source) {
3718 void* ptr;
3719
3720 if (wxPySwigInstance_Check(source) &&
3721 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3722 return true;
3723
3724 PyErr_Clear();
3725 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3726 return true;
3727
3728 return false;
3729 }
3730
3731
3732 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3733 {
3734 PyObject* list = PyList_New(0);
3735 size_t idx;
3736 for (idx = 0; idx < source.GetCount(); idx += 1) {
3737 wxGridCellCoords& coord = source.Item(idx);
3738 PyObject* tup = PyTuple_New(2);
3739 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3740 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3741 PyList_Append(list, tup);
3742 Py_DECREF(tup);
3743 }
3744 return list;
3745 }
3746
3747 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3748 wxGridCellCoords temp, *obj = &temp;
3749 if ( other == Py_None ) return false;
3750 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3751 PyErr_Clear();
3752 return false;
3753 }
3754 return self->operator==(*obj);
3755 }
3756 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3757 wxGridCellCoords temp, *obj = &temp;
3758 if ( other == Py_None ) return true;
3759 if ( ! wxGridCellCoords_helper(other, &obj)) {
3760 PyErr_Clear();
3761 return true;
3762 }
3763 return self->operator!=(*obj);
3764 }
3765 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3766 PyObject* tup = PyTuple_New(2);
3767 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3768 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3769 return tup;
3770 }
3771
3772 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3773
3774 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3775 wxGridCellCoords rv;
3776 self->XYToCell(x, y, rv);
3777 return rv;
3778 }
3779 #ifdef __cplusplus
3780 extern "C" {
3781 #endif
3782 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3783 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3784 return 1;
3785 }
3786
3787
3788 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3789 PyObject *pyobj = 0;
3790
3791 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3792 return pyobj;
3793 }
3794
3795
3796 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3797 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3798 return 1;
3799 }
3800
3801
3802 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3803 PyObject *pyobj = 0;
3804
3805 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3806 return pyobj;
3807 }
3808
3809
3810 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3811 PyObject *resultobj = 0;
3812 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3813 PyObject *arg2 = (PyObject *) 0 ;
3814 void *argp1 = 0 ;
3815 int res1 = 0 ;
3816 PyObject * obj0 = 0 ;
3817 PyObject * obj1 = 0 ;
3818 char * kwnames[] = {
3819 (char *) "self",(char *) "_self", NULL
3820 };
3821
3822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3824 if (!SWIG_IsOK(res1)) {
3825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3826 }
3827 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3828 arg2 = obj1;
3829 {
3830 PyThreadState* __tstate = wxPyBeginAllowThreads();
3831 wxGridCellWorker__setOORInfo(arg1,arg2);
3832 wxPyEndAllowThreads(__tstate);
3833 if (PyErr_Occurred()) SWIG_fail;
3834 }
3835 resultobj = SWIG_Py_Void();
3836 return resultobj;
3837 fail:
3838 return NULL;
3839 }
3840
3841
3842 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3843 PyObject *resultobj = 0;
3844 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3845 void *argp1 = 0 ;
3846 int res1 = 0 ;
3847 PyObject *swig_obj[1] ;
3848
3849 if (!args) SWIG_fail;
3850 swig_obj[0] = args;
3851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3852 if (!SWIG_IsOK(res1)) {
3853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3854 }
3855 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3856 {
3857 PyThreadState* __tstate = wxPyBeginAllowThreads();
3858 delete_wxGridCellWorker(arg1);
3859
3860 wxPyEndAllowThreads(__tstate);
3861 if (PyErr_Occurred()) SWIG_fail;
3862 }
3863 resultobj = SWIG_Py_Void();
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
3870 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3871 PyObject *resultobj = 0;
3872 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3873 wxString *arg2 = 0 ;
3874 void *argp1 = 0 ;
3875 int res1 = 0 ;
3876 bool temp2 = false ;
3877 PyObject * obj0 = 0 ;
3878 PyObject * obj1 = 0 ;
3879 char * kwnames[] = {
3880 (char *) "self",(char *) "params", NULL
3881 };
3882
3883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3885 if (!SWIG_IsOK(res1)) {
3886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3887 }
3888 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3889 {
3890 arg2 = wxString_in_helper(obj1);
3891 if (arg2 == NULL) SWIG_fail;
3892 temp2 = true;
3893 }
3894 {
3895 PyThreadState* __tstate = wxPyBeginAllowThreads();
3896 (arg1)->SetParameters((wxString const &)*arg2);
3897 wxPyEndAllowThreads(__tstate);
3898 if (PyErr_Occurred()) SWIG_fail;
3899 }
3900 resultobj = SWIG_Py_Void();
3901 {
3902 if (temp2)
3903 delete arg2;
3904 }
3905 return resultobj;
3906 fail:
3907 {
3908 if (temp2)
3909 delete arg2;
3910 }
3911 return NULL;
3912 }
3913
3914
3915 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3916 PyObject *resultobj = 0;
3917 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3918 void *argp1 = 0 ;
3919 int res1 = 0 ;
3920 PyObject *swig_obj[1] ;
3921
3922 if (!args) SWIG_fail;
3923 swig_obj[0] = args;
3924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3925 if (!SWIG_IsOK(res1)) {
3926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3927 }
3928 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3929 {
3930 PyThreadState* __tstate = wxPyBeginAllowThreads();
3931 (arg1)->IncRef();
3932 wxPyEndAllowThreads(__tstate);
3933 if (PyErr_Occurred()) SWIG_fail;
3934 }
3935 resultobj = SWIG_Py_Void();
3936 return resultobj;
3937 fail:
3938 return NULL;
3939 }
3940
3941
3942 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3943 PyObject *resultobj = 0;
3944 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3945 void *argp1 = 0 ;
3946 int res1 = 0 ;
3947 PyObject *swig_obj[1] ;
3948
3949 if (!args) SWIG_fail;
3950 swig_obj[0] = args;
3951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3952 if (!SWIG_IsOK(res1)) {
3953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3954 }
3955 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3956 {
3957 PyThreadState* __tstate = wxPyBeginAllowThreads();
3958 (arg1)->DecRef();
3959 wxPyEndAllowThreads(__tstate);
3960 if (PyErr_Occurred()) SWIG_fail;
3961 }
3962 resultobj = SWIG_Py_Void();
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3970 PyObject *obj;
3971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3972 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3973 return SWIG_Py_Void();
3974 }
3975
3976 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3977 PyObject *obj;
3978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3979 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
3980 return SWIG_Py_Void();
3981 }
3982
3983 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3984 PyObject *resultobj = 0;
3985 wxPyGridCellRenderer *result = 0 ;
3986
3987 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
3988 {
3989 PyThreadState* __tstate = wxPyBeginAllowThreads();
3990 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3991 wxPyEndAllowThreads(__tstate);
3992 if (PyErr_Occurred()) SWIG_fail;
3993 }
3994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
3995 return resultobj;
3996 fail:
3997 return NULL;
3998 }
3999
4000
4001 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4002 PyObject *resultobj = 0;
4003 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4004 PyObject *arg2 = (PyObject *) 0 ;
4005 PyObject *arg3 = (PyObject *) 0 ;
4006 void *argp1 = 0 ;
4007 int res1 = 0 ;
4008 PyObject * obj0 = 0 ;
4009 PyObject * obj1 = 0 ;
4010 PyObject * obj2 = 0 ;
4011 char * kwnames[] = {
4012 (char *) "self",(char *) "self",(char *) "_class", NULL
4013 };
4014
4015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4017 if (!SWIG_IsOK(res1)) {
4018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4019 }
4020 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4021 arg2 = obj1;
4022 arg3 = obj2;
4023 {
4024 PyThreadState* __tstate = wxPyBeginAllowThreads();
4025 (arg1)->_setCallbackInfo(arg2,arg3);
4026 wxPyEndAllowThreads(__tstate);
4027 if (PyErr_Occurred()) SWIG_fail;
4028 }
4029 resultobj = SWIG_Py_Void();
4030 return resultobj;
4031 fail:
4032 return NULL;
4033 }
4034
4035
4036 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4037 PyObject *resultobj = 0;
4038 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4039 wxString *arg2 = 0 ;
4040 void *argp1 = 0 ;
4041 int res1 = 0 ;
4042 bool temp2 = false ;
4043 PyObject * obj0 = 0 ;
4044 PyObject * obj1 = 0 ;
4045 char * kwnames[] = {
4046 (char *) "self",(char *) "params", NULL
4047 };
4048
4049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4051 if (!SWIG_IsOK(res1)) {
4052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4053 }
4054 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4055 {
4056 arg2 = wxString_in_helper(obj1);
4057 if (arg2 == NULL) SWIG_fail;
4058 temp2 = true;
4059 }
4060 {
4061 PyThreadState* __tstate = wxPyBeginAllowThreads();
4062 (arg1)->SetParameters((wxString const &)*arg2);
4063 wxPyEndAllowThreads(__tstate);
4064 if (PyErr_Occurred()) SWIG_fail;
4065 }
4066 resultobj = SWIG_Py_Void();
4067 {
4068 if (temp2)
4069 delete arg2;
4070 }
4071 return resultobj;
4072 fail:
4073 {
4074 if (temp2)
4075 delete arg2;
4076 }
4077 return NULL;
4078 }
4079
4080
4081 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4082 PyObject *obj;
4083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4084 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4085 return SWIG_Py_Void();
4086 }
4087
4088 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4089 return SWIG_Python_InitShadowInstance(args);
4090 }
4091
4092 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4093 PyObject *resultobj = 0;
4094 wxGridCellStringRenderer *result = 0 ;
4095
4096 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4097 {
4098 PyThreadState* __tstate = wxPyBeginAllowThreads();
4099 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4100 wxPyEndAllowThreads(__tstate);
4101 if (PyErr_Occurred()) SWIG_fail;
4102 }
4103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4104 return resultobj;
4105 fail:
4106 return NULL;
4107 }
4108
4109
4110 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4111 PyObject *obj;
4112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4113 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4114 return SWIG_Py_Void();
4115 }
4116
4117 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4118 return SWIG_Python_InitShadowInstance(args);
4119 }
4120
4121 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4122 PyObject *resultobj = 0;
4123 wxGridCellNumberRenderer *result = 0 ;
4124
4125 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4126 {
4127 PyThreadState* __tstate = wxPyBeginAllowThreads();
4128 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4133 return resultobj;
4134 fail:
4135 return NULL;
4136 }
4137
4138
4139 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4140 PyObject *obj;
4141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4142 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4143 return SWIG_Py_Void();
4144 }
4145
4146 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4147 return SWIG_Python_InitShadowInstance(args);
4148 }
4149
4150 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj = 0;
4152 int arg1 = (int) -1 ;
4153 int arg2 = (int) -1 ;
4154 wxGridCellFloatRenderer *result = 0 ;
4155 int val1 ;
4156 int ecode1 = 0 ;
4157 int val2 ;
4158 int ecode2 = 0 ;
4159 PyObject * obj0 = 0 ;
4160 PyObject * obj1 = 0 ;
4161 char * kwnames[] = {
4162 (char *) "width",(char *) "precision", NULL
4163 };
4164
4165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4166 if (obj0) {
4167 ecode1 = SWIG_AsVal_int(obj0, &val1);
4168 if (!SWIG_IsOK(ecode1)) {
4169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4170 }
4171 arg1 = static_cast< int >(val1);
4172 }
4173 if (obj1) {
4174 ecode2 = SWIG_AsVal_int(obj1, &val2);
4175 if (!SWIG_IsOK(ecode2)) {
4176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4177 }
4178 arg2 = static_cast< int >(val2);
4179 }
4180 {
4181 PyThreadState* __tstate = wxPyBeginAllowThreads();
4182 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4183 wxPyEndAllowThreads(__tstate);
4184 if (PyErr_Occurred()) SWIG_fail;
4185 }
4186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4187 return resultobj;
4188 fail:
4189 return NULL;
4190 }
4191
4192
4193 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4194 PyObject *resultobj = 0;
4195 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4196 int result;
4197 void *argp1 = 0 ;
4198 int res1 = 0 ;
4199 PyObject *swig_obj[1] ;
4200
4201 if (!args) SWIG_fail;
4202 swig_obj[0] = args;
4203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4204 if (!SWIG_IsOK(res1)) {
4205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4206 }
4207 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 resultobj = SWIG_From_int(static_cast< int >(result));
4215 return resultobj;
4216 fail:
4217 return NULL;
4218 }
4219
4220
4221 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4222 PyObject *resultobj = 0;
4223 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4224 int arg2 ;
4225 void *argp1 = 0 ;
4226 int res1 = 0 ;
4227 int val2 ;
4228 int ecode2 = 0 ;
4229 PyObject * obj0 = 0 ;
4230 PyObject * obj1 = 0 ;
4231 char * kwnames[] = {
4232 (char *) "self",(char *) "width", NULL
4233 };
4234
4235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4237 if (!SWIG_IsOK(res1)) {
4238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4239 }
4240 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4241 ecode2 = SWIG_AsVal_int(obj1, &val2);
4242 if (!SWIG_IsOK(ecode2)) {
4243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4244 }
4245 arg2 = static_cast< int >(val2);
4246 {
4247 PyThreadState* __tstate = wxPyBeginAllowThreads();
4248 (arg1)->SetWidth(arg2);
4249 wxPyEndAllowThreads(__tstate);
4250 if (PyErr_Occurred()) SWIG_fail;
4251 }
4252 resultobj = SWIG_Py_Void();
4253 return resultobj;
4254 fail:
4255 return NULL;
4256 }
4257
4258
4259 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4260 PyObject *resultobj = 0;
4261 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4262 int result;
4263 void *argp1 = 0 ;
4264 int res1 = 0 ;
4265 PyObject *swig_obj[1] ;
4266
4267 if (!args) SWIG_fail;
4268 swig_obj[0] = args;
4269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4270 if (!SWIG_IsOK(res1)) {
4271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4272 }
4273 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4274 {
4275 PyThreadState* __tstate = wxPyBeginAllowThreads();
4276 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 resultobj = SWIG_From_int(static_cast< int >(result));
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4288 PyObject *resultobj = 0;
4289 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4290 int arg2 ;
4291 void *argp1 = 0 ;
4292 int res1 = 0 ;
4293 int val2 ;
4294 int ecode2 = 0 ;
4295 PyObject * obj0 = 0 ;
4296 PyObject * obj1 = 0 ;
4297 char * kwnames[] = {
4298 (char *) "self",(char *) "precision", NULL
4299 };
4300
4301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4303 if (!SWIG_IsOK(res1)) {
4304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4305 }
4306 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4307 ecode2 = SWIG_AsVal_int(obj1, &val2);
4308 if (!SWIG_IsOK(ecode2)) {
4309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4310 }
4311 arg2 = static_cast< int >(val2);
4312 {
4313 PyThreadState* __tstate = wxPyBeginAllowThreads();
4314 (arg1)->SetPrecision(arg2);
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 resultobj = SWIG_Py_Void();
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4326 PyObject *obj;
4327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4328 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4329 return SWIG_Py_Void();
4330 }
4331
4332 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4333 return SWIG_Python_InitShadowInstance(args);
4334 }
4335
4336 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337 PyObject *resultobj = 0;
4338 wxGridCellBoolRenderer *result = 0 ;
4339
4340 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4341 {
4342 PyThreadState* __tstate = wxPyBeginAllowThreads();
4343 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4348 return resultobj;
4349 fail:
4350 return NULL;
4351 }
4352
4353
4354 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4355 PyObject *obj;
4356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4357 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4358 return SWIG_Py_Void();
4359 }
4360
4361 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4362 return SWIG_Python_InitShadowInstance(args);
4363 }
4364
4365 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj = 0;
4367 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4368 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4369 wxGridCellDateTimeRenderer *result = 0 ;
4370 PyObject * obj0 = 0 ;
4371 PyObject * obj1 = 0 ;
4372 char * kwnames[] = {
4373 (char *) "outformat",(char *) "informat", NULL
4374 };
4375
4376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4377 if (obj0) {
4378 {
4379 wxString* sptr = wxString_in_helper(obj0);
4380 if (sptr == NULL) SWIG_fail;
4381 arg1 = *sptr;
4382 delete sptr;
4383 }
4384 }
4385 if (obj1) {
4386 {
4387 wxString* sptr = wxString_in_helper(obj1);
4388 if (sptr == NULL) SWIG_fail;
4389 arg2 = *sptr;
4390 delete sptr;
4391 }
4392 }
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4400 return resultobj;
4401 fail:
4402 return NULL;
4403 }
4404
4405
4406 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4407 PyObject *obj;
4408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4409 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4410 return SWIG_Py_Void();
4411 }
4412
4413 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 return SWIG_Python_InitShadowInstance(args);
4415 }
4416
4417 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4418 PyObject *resultobj = 0;
4419 wxString const &arg1_defvalue = wxPyEmptyString ;
4420 wxString *arg1 = (wxString *) &arg1_defvalue ;
4421 wxGridCellEnumRenderer *result = 0 ;
4422 bool temp1 = false ;
4423 PyObject * obj0 = 0 ;
4424 char * kwnames[] = {
4425 (char *) "choices", NULL
4426 };
4427
4428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4429 if (obj0) {
4430 {
4431 arg1 = wxString_in_helper(obj0);
4432 if (arg1 == NULL) SWIG_fail;
4433 temp1 = true;
4434 }
4435 }
4436 {
4437 PyThreadState* __tstate = wxPyBeginAllowThreads();
4438 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4439 wxPyEndAllowThreads(__tstate);
4440 if (PyErr_Occurred()) SWIG_fail;
4441 }
4442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4443 {
4444 if (temp1)
4445 delete arg1;
4446 }
4447 return resultobj;
4448 fail:
4449 {
4450 if (temp1)
4451 delete arg1;
4452 }
4453 return NULL;
4454 }
4455
4456
4457 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 PyObject *obj;
4459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4460 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4461 return SWIG_Py_Void();
4462 }
4463
4464 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4465 return SWIG_Python_InitShadowInstance(args);
4466 }
4467
4468 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4469 PyObject *resultobj = 0;
4470 wxGridCellAutoWrapStringRenderer *result = 0 ;
4471
4472 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4473 {
4474 PyThreadState* __tstate = wxPyBeginAllowThreads();
4475 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4480 return resultobj;
4481 fail:
4482 return NULL;
4483 }
4484
4485
4486 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4487 PyObject *obj;
4488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4489 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4490 return SWIG_Py_Void();
4491 }
4492
4493 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4494 return SWIG_Python_InitShadowInstance(args);
4495 }
4496
4497 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4498 PyObject *resultobj = 0;
4499 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4500 bool result;
4501 void *argp1 = 0 ;
4502 int res1 = 0 ;
4503 PyObject *swig_obj[1] ;
4504
4505 if (!args) SWIG_fail;
4506 swig_obj[0] = args;
4507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4508 if (!SWIG_IsOK(res1)) {
4509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4510 }
4511 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4512 {
4513 PyThreadState* __tstate = wxPyBeginAllowThreads();
4514 result = (bool)(arg1)->IsCreated();
4515 wxPyEndAllowThreads(__tstate);
4516 if (PyErr_Occurred()) SWIG_fail;
4517 }
4518 {
4519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4520 }
4521 return resultobj;
4522 fail:
4523 return NULL;
4524 }
4525
4526
4527 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4528 PyObject *resultobj = 0;
4529 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4530 wxControl *result = 0 ;
4531 void *argp1 = 0 ;
4532 int res1 = 0 ;
4533 PyObject *swig_obj[1] ;
4534
4535 if (!args) SWIG_fail;
4536 swig_obj[0] = args;
4537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4538 if (!SWIG_IsOK(res1)) {
4539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4540 }
4541 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4542 {
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = (wxControl *)(arg1)->GetControl();
4545 wxPyEndAllowThreads(__tstate);
4546 if (PyErr_Occurred()) SWIG_fail;
4547 }
4548 {
4549 resultobj = wxPyMake_wxObject(result, 0);
4550 }
4551 return resultobj;
4552 fail:
4553 return NULL;
4554 }
4555
4556
4557 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4558 PyObject *resultobj = 0;
4559 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4560 wxControl *arg2 = (wxControl *) 0 ;
4561 void *argp1 = 0 ;
4562 int res1 = 0 ;
4563 void *argp2 = 0 ;
4564 int res2 = 0 ;
4565 PyObject * obj0 = 0 ;
4566 PyObject * obj1 = 0 ;
4567 char * kwnames[] = {
4568 (char *) "self",(char *) "control", NULL
4569 };
4570
4571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4573 if (!SWIG_IsOK(res1)) {
4574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4575 }
4576 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4578 if (!SWIG_IsOK(res2)) {
4579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4580 }
4581 arg2 = reinterpret_cast< wxControl * >(argp2);
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 (arg1)->SetControl(arg2);
4585 wxPyEndAllowThreads(__tstate);
4586 if (PyErr_Occurred()) SWIG_fail;
4587 }
4588 resultobj = SWIG_Py_Void();
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4596 PyObject *resultobj = 0;
4597 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4598 wxGridCellAttr *result = 0 ;
4599 void *argp1 = 0 ;
4600 int res1 = 0 ;
4601 PyObject *swig_obj[1] ;
4602
4603 if (!args) SWIG_fail;
4604 swig_obj[0] = args;
4605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4606 if (!SWIG_IsOK(res1)) {
4607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4608 }
4609 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4610 {
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4613 wxPyEndAllowThreads(__tstate);
4614 if (PyErr_Occurred()) SWIG_fail;
4615 }
4616 {
4617 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4618 }
4619 return resultobj;
4620 fail:
4621 return NULL;
4622 }
4623
4624
4625 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4626 PyObject *resultobj = 0;
4627 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4628 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4629 void *argp1 = 0 ;
4630 int res1 = 0 ;
4631 void *argp2 = 0 ;
4632 int res2 = 0 ;
4633 PyObject * obj0 = 0 ;
4634 PyObject * obj1 = 0 ;
4635 char * kwnames[] = {
4636 (char *) "self",(char *) "attr", NULL
4637 };
4638
4639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4643 }
4644 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4646 if (!SWIG_IsOK(res2)) {
4647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4648 }
4649 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4650 {
4651 PyThreadState* __tstate = wxPyBeginAllowThreads();
4652 (arg1)->SetCellAttr(arg2);
4653 wxPyEndAllowThreads(__tstate);
4654 if (PyErr_Occurred()) SWIG_fail;
4655 }
4656 resultobj = SWIG_Py_Void();
4657 return resultobj;
4658 fail:
4659 return NULL;
4660 }
4661
4662
4663 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4664 PyObject *resultobj = 0;
4665 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4666 wxWindow *arg2 = (wxWindow *) 0 ;
4667 int arg3 ;
4668 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4669 void *argp1 = 0 ;
4670 int res1 = 0 ;
4671 void *argp2 = 0 ;
4672 int res2 = 0 ;
4673 int val3 ;
4674 int ecode3 = 0 ;
4675 void *argp4 = 0 ;
4676 int res4 = 0 ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 PyObject * obj2 = 0 ;
4680 PyObject * obj3 = 0 ;
4681 char * kwnames[] = {
4682 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4683 };
4684
4685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4687 if (!SWIG_IsOK(res1)) {
4688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4689 }
4690 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4692 if (!SWIG_IsOK(res2)) {
4693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4694 }
4695 arg2 = reinterpret_cast< wxWindow * >(argp2);
4696 ecode3 = SWIG_AsVal_int(obj2, &val3);
4697 if (!SWIG_IsOK(ecode3)) {
4698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4699 }
4700 arg3 = static_cast< int >(val3);
4701 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4702 if (!SWIG_IsOK(res4)) {
4703 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4704 }
4705 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4706 {
4707 PyThreadState* __tstate = wxPyBeginAllowThreads();
4708 (arg1)->Create(arg2,arg3,arg4);
4709 wxPyEndAllowThreads(__tstate);
4710 if (PyErr_Occurred()) SWIG_fail;
4711 }
4712 resultobj = SWIG_Py_Void();
4713 return resultobj;
4714 fail:
4715 return NULL;
4716 }
4717
4718
4719 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4720 PyObject *resultobj = 0;
4721 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4722 int arg2 ;
4723 int arg3 ;
4724 wxGrid *arg4 = (wxGrid *) 0 ;
4725 void *argp1 = 0 ;
4726 int res1 = 0 ;
4727 int val2 ;
4728 int ecode2 = 0 ;
4729 int val3 ;
4730 int ecode3 = 0 ;
4731 void *argp4 = 0 ;
4732 int res4 = 0 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 PyObject * obj2 = 0 ;
4736 PyObject * obj3 = 0 ;
4737 char * kwnames[] = {
4738 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4739 };
4740
4741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4743 if (!SWIG_IsOK(res1)) {
4744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4745 }
4746 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4747 ecode2 = SWIG_AsVal_int(obj1, &val2);
4748 if (!SWIG_IsOK(ecode2)) {
4749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4750 }
4751 arg2 = static_cast< int >(val2);
4752 ecode3 = SWIG_AsVal_int(obj2, &val3);
4753 if (!SWIG_IsOK(ecode3)) {
4754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4755 }
4756 arg3 = static_cast< int >(val3);
4757 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4758 if (!SWIG_IsOK(res4)) {
4759 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4760 }
4761 arg4 = reinterpret_cast< wxGrid * >(argp4);
4762 {
4763 PyThreadState* __tstate = wxPyBeginAllowThreads();
4764 (arg1)->BeginEdit(arg2,arg3,arg4);
4765 wxPyEndAllowThreads(__tstate);
4766 if (PyErr_Occurred()) SWIG_fail;
4767 }
4768 resultobj = SWIG_Py_Void();
4769 return resultobj;
4770 fail:
4771 return NULL;
4772 }
4773
4774
4775 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4776 PyObject *resultobj = 0;
4777 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4778 int arg2 ;
4779 int arg3 ;
4780 wxGrid *arg4 = (wxGrid *) 0 ;
4781 bool result;
4782 void *argp1 = 0 ;
4783 int res1 = 0 ;
4784 int val2 ;
4785 int ecode2 = 0 ;
4786 int val3 ;
4787 int ecode3 = 0 ;
4788 void *argp4 = 0 ;
4789 int res4 = 0 ;
4790 PyObject * obj0 = 0 ;
4791 PyObject * obj1 = 0 ;
4792 PyObject * obj2 = 0 ;
4793 PyObject * obj3 = 0 ;
4794 char * kwnames[] = {
4795 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4796 };
4797
4798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4800 if (!SWIG_IsOK(res1)) {
4801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4802 }
4803 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4804 ecode2 = SWIG_AsVal_int(obj1, &val2);
4805 if (!SWIG_IsOK(ecode2)) {
4806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
4807 }
4808 arg2 = static_cast< int >(val2);
4809 ecode3 = SWIG_AsVal_int(obj2, &val3);
4810 if (!SWIG_IsOK(ecode3)) {
4811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
4812 }
4813 arg3 = static_cast< int >(val3);
4814 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4815 if (!SWIG_IsOK(res4)) {
4816 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4817 }
4818 arg4 = reinterpret_cast< wxGrid * >(argp4);
4819 {
4820 PyThreadState* __tstate = wxPyBeginAllowThreads();
4821 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4822 wxPyEndAllowThreads(__tstate);
4823 if (PyErr_Occurred()) SWIG_fail;
4824 }
4825 {
4826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4827 }
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4835 PyObject *resultobj = 0;
4836 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4837 void *argp1 = 0 ;
4838 int res1 = 0 ;
4839 PyObject *swig_obj[1] ;
4840
4841 if (!args) SWIG_fail;
4842 swig_obj[0] = args;
4843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4844 if (!SWIG_IsOK(res1)) {
4845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4846 }
4847 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4848 {
4849 PyThreadState* __tstate = wxPyBeginAllowThreads();
4850 (arg1)->Reset();
4851 wxPyEndAllowThreads(__tstate);
4852 if (PyErr_Occurred()) SWIG_fail;
4853 }
4854 resultobj = SWIG_Py_Void();
4855 return resultobj;
4856 fail:
4857 return NULL;
4858 }
4859
4860
4861 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4862 PyObject *resultobj = 0;
4863 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4864 wxGridCellEditor *result = 0 ;
4865 void *argp1 = 0 ;
4866 int res1 = 0 ;
4867 PyObject *swig_obj[1] ;
4868
4869 if (!args) SWIG_fail;
4870 swig_obj[0] = args;
4871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4872 if (!SWIG_IsOK(res1)) {
4873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
4874 }
4875 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4876 {
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 {
4883 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4884 }
4885 return resultobj;
4886 fail:
4887 return NULL;
4888 }
4889
4890
4891 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4892 PyObject *resultobj = 0;
4893 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4894 wxRect *arg2 = 0 ;
4895 void *argp1 = 0 ;
4896 int res1 = 0 ;
4897 wxRect temp2 ;
4898 PyObject * obj0 = 0 ;
4899 PyObject * obj1 = 0 ;
4900 char * kwnames[] = {
4901 (char *) "self",(char *) "rect", NULL
4902 };
4903
4904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
4905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4906 if (!SWIG_IsOK(res1)) {
4907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4908 }
4909 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4910 {
4911 arg2 = &temp2;
4912 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4913 }
4914 {
4915 PyThreadState* __tstate = wxPyBeginAllowThreads();
4916 (arg1)->SetSize((wxRect const &)*arg2);
4917 wxPyEndAllowThreads(__tstate);
4918 if (PyErr_Occurred()) SWIG_fail;
4919 }
4920 resultobj = SWIG_Py_Void();
4921 return resultobj;
4922 fail:
4923 return NULL;
4924 }
4925
4926
4927 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4928 PyObject *resultobj = 0;
4929 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4930 bool arg2 ;
4931 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4932 void *argp1 = 0 ;
4933 int res1 = 0 ;
4934 bool val2 ;
4935 int ecode2 = 0 ;
4936 void *argp3 = 0 ;
4937 int res3 = 0 ;
4938 PyObject * obj0 = 0 ;
4939 PyObject * obj1 = 0 ;
4940 PyObject * obj2 = 0 ;
4941 char * kwnames[] = {
4942 (char *) "self",(char *) "show",(char *) "attr", NULL
4943 };
4944
4945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4947 if (!SWIG_IsOK(res1)) {
4948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4949 }
4950 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4951 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4952 if (!SWIG_IsOK(ecode2)) {
4953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
4954 }
4955 arg2 = static_cast< bool >(val2);
4956 if (obj2) {
4957 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4958 if (!SWIG_IsOK(res3)) {
4959 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4960 }
4961 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4962 }
4963 {
4964 PyThreadState* __tstate = wxPyBeginAllowThreads();
4965 (arg1)->Show(arg2,arg3);
4966 wxPyEndAllowThreads(__tstate);
4967 if (PyErr_Occurred()) SWIG_fail;
4968 }
4969 resultobj = SWIG_Py_Void();
4970 return resultobj;
4971 fail:
4972 return NULL;
4973 }
4974
4975
4976 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4977 PyObject *resultobj = 0;
4978 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4979 wxRect *arg2 = 0 ;
4980 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4981 void *argp1 = 0 ;
4982 int res1 = 0 ;
4983 wxRect temp2 ;
4984 void *argp3 = 0 ;
4985 int res3 = 0 ;
4986 PyObject * obj0 = 0 ;
4987 PyObject * obj1 = 0 ;
4988 PyObject * obj2 = 0 ;
4989 char * kwnames[] = {
4990 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4991 };
4992
4993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4995 if (!SWIG_IsOK(res1)) {
4996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4997 }
4998 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4999 {
5000 arg2 = &temp2;
5001 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5002 }
5003 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5004 if (!SWIG_IsOK(res3)) {
5005 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5006 }
5007 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5008 {
5009 PyThreadState* __tstate = wxPyBeginAllowThreads();
5010 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5011 wxPyEndAllowThreads(__tstate);
5012 if (PyErr_Occurred()) SWIG_fail;
5013 }
5014 resultobj = SWIG_Py_Void();
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
5021 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5022 PyObject *resultobj = 0;
5023 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5024 wxKeyEvent *arg2 = 0 ;
5025 bool result;
5026 void *argp1 = 0 ;
5027 int res1 = 0 ;
5028 void *argp2 = 0 ;
5029 int res2 = 0 ;
5030 PyObject * obj0 = 0 ;
5031 PyObject * obj1 = 0 ;
5032 char * kwnames[] = {
5033 (char *) "self",(char *) "event", NULL
5034 };
5035
5036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5038 if (!SWIG_IsOK(res1)) {
5039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5040 }
5041 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5043 if (!SWIG_IsOK(res2)) {
5044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5045 }
5046 if (!argp2) {
5047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5048 }
5049 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5050 {
5051 PyThreadState* __tstate = wxPyBeginAllowThreads();
5052 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5053 wxPyEndAllowThreads(__tstate);
5054 if (PyErr_Occurred()) SWIG_fail;
5055 }
5056 {
5057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5058 }
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj = 0;
5067 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5068 wxKeyEvent *arg2 = 0 ;
5069 void *argp1 = 0 ;
5070 int res1 = 0 ;
5071 void *argp2 = 0 ;
5072 int res2 = 0 ;
5073 PyObject * obj0 = 0 ;
5074 PyObject * obj1 = 0 ;
5075 char * kwnames[] = {
5076 (char *) "self",(char *) "event", NULL
5077 };
5078
5079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5081 if (!SWIG_IsOK(res1)) {
5082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5083 }
5084 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5085 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5086 if (!SWIG_IsOK(res2)) {
5087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5088 }
5089 if (!argp2) {
5090 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5091 }
5092 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5093 {
5094 PyThreadState* __tstate = wxPyBeginAllowThreads();
5095 (arg1)->StartingKey(*arg2);
5096 wxPyEndAllowThreads(__tstate);
5097 if (PyErr_Occurred()) SWIG_fail;
5098 }
5099 resultobj = SWIG_Py_Void();
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5107 PyObject *resultobj = 0;
5108 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5109 void *argp1 = 0 ;
5110 int res1 = 0 ;
5111 PyObject *swig_obj[1] ;
5112
5113 if (!args) SWIG_fail;
5114 swig_obj[0] = args;
5115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5116 if (!SWIG_IsOK(res1)) {
5117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5118 }
5119 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5120 {
5121 PyThreadState* __tstate = wxPyBeginAllowThreads();
5122 (arg1)->StartingClick();
5123 wxPyEndAllowThreads(__tstate);
5124 if (PyErr_Occurred()) SWIG_fail;
5125 }
5126 resultobj = SWIG_Py_Void();
5127 return resultobj;
5128 fail:
5129 return NULL;
5130 }
5131
5132
5133 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5134 PyObject *resultobj = 0;
5135 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5136 wxKeyEvent *arg2 = 0 ;
5137 void *argp1 = 0 ;
5138 int res1 = 0 ;
5139 void *argp2 = 0 ;
5140 int res2 = 0 ;
5141 PyObject * obj0 = 0 ;
5142 PyObject * obj1 = 0 ;
5143 char * kwnames[] = {
5144 (char *) "self",(char *) "event", NULL
5145 };
5146
5147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5149 if (!SWIG_IsOK(res1)) {
5150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5151 }
5152 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5154 if (!SWIG_IsOK(res2)) {
5155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5156 }
5157 if (!argp2) {
5158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5159 }
5160 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 (arg1)->HandleReturn(*arg2);
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 resultobj = SWIG_Py_Void();
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5175 PyObject *resultobj = 0;
5176 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5177 void *argp1 = 0 ;
5178 int res1 = 0 ;
5179 PyObject *swig_obj[1] ;
5180
5181 if (!args) SWIG_fail;
5182 swig_obj[0] = args;
5183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5184 if (!SWIG_IsOK(res1)) {
5185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5186 }
5187 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5188 {
5189 PyThreadState* __tstate = wxPyBeginAllowThreads();
5190 (arg1)->Destroy();
5191 wxPyEndAllowThreads(__tstate);
5192 if (PyErr_Occurred()) SWIG_fail;
5193 }
5194 resultobj = SWIG_Py_Void();
5195 return resultobj;
5196 fail:
5197 return NULL;
5198 }
5199
5200
5201 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *obj;
5203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5204 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5205 return SWIG_Py_Void();
5206 }
5207
5208 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5209 PyObject *resultobj = 0;
5210 wxPyGridCellEditor *result = 0 ;
5211
5212 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5213 {
5214 PyThreadState* __tstate = wxPyBeginAllowThreads();
5215 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5216 wxPyEndAllowThreads(__tstate);
5217 if (PyErr_Occurred()) SWIG_fail;
5218 }
5219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj = 0;
5228 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5229 PyObject *arg2 = (PyObject *) 0 ;
5230 PyObject *arg3 = (PyObject *) 0 ;
5231 void *argp1 = 0 ;
5232 int res1 = 0 ;
5233 PyObject * obj0 = 0 ;
5234 PyObject * obj1 = 0 ;
5235 PyObject * obj2 = 0 ;
5236 char * kwnames[] = {
5237 (char *) "self",(char *) "self",(char *) "_class", NULL
5238 };
5239
5240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5242 if (!SWIG_IsOK(res1)) {
5243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5244 }
5245 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5246 arg2 = obj1;
5247 arg3 = obj2;
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 (arg1)->_setCallbackInfo(arg2,arg3);
5251 wxPyEndAllowThreads(__tstate);
5252 if (PyErr_Occurred()) SWIG_fail;
5253 }
5254 resultobj = SWIG_Py_Void();
5255 return resultobj;
5256 fail:
5257 return NULL;
5258 }
5259
5260
5261 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5262 PyObject *resultobj = 0;
5263 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5264 wxString *arg2 = 0 ;
5265 void *argp1 = 0 ;
5266 int res1 = 0 ;
5267 bool temp2 = false ;
5268 PyObject * obj0 = 0 ;
5269 PyObject * obj1 = 0 ;
5270 char * kwnames[] = {
5271 (char *) "self",(char *) "params", NULL
5272 };
5273
5274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5276 if (!SWIG_IsOK(res1)) {
5277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5278 }
5279 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5280 {
5281 arg2 = wxString_in_helper(obj1);
5282 if (arg2 == NULL) SWIG_fail;
5283 temp2 = true;
5284 }
5285 {
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 (arg1)->SetParameters((wxString const &)*arg2);
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 resultobj = SWIG_Py_Void();
5292 {
5293 if (temp2)
5294 delete arg2;
5295 }
5296 return resultobj;
5297 fail:
5298 {
5299 if (temp2)
5300 delete arg2;
5301 }
5302 return NULL;
5303 }
5304
5305
5306 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5307 PyObject *obj;
5308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5309 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5310 return SWIG_Py_Void();
5311 }
5312
5313 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5314 return SWIG_Python_InitShadowInstance(args);
5315 }
5316
5317 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5318 PyObject *resultobj = 0;
5319 wxGridCellTextEditor *result = 0 ;
5320
5321 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5336 PyObject *resultobj = 0;
5337 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5338 wxString result;
5339 void *argp1 = 0 ;
5340 int res1 = 0 ;
5341 PyObject *swig_obj[1] ;
5342
5343 if (!args) SWIG_fail;
5344 swig_obj[0] = args;
5345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5346 if (!SWIG_IsOK(res1)) {
5347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5348 }
5349 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 result = (arg1)->GetValue();
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 {
5357 #if wxUSE_UNICODE
5358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5359 #else
5360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5361 #endif
5362 }
5363 return resultobj;
5364 fail:
5365 return NULL;
5366 }
5367
5368
5369 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5370 PyObject *obj;
5371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5372 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5373 return SWIG_Py_Void();
5374 }
5375
5376 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5377 return SWIG_Python_InitShadowInstance(args);
5378 }
5379
5380 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5381 PyObject *resultobj = 0;
5382 int arg1 = (int) -1 ;
5383 int arg2 = (int) -1 ;
5384 wxGridCellNumberEditor *result = 0 ;
5385 int val1 ;
5386 int ecode1 = 0 ;
5387 int val2 ;
5388 int ecode2 = 0 ;
5389 PyObject * obj0 = 0 ;
5390 PyObject * obj1 = 0 ;
5391 char * kwnames[] = {
5392 (char *) "min",(char *) "max", NULL
5393 };
5394
5395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5396 if (obj0) {
5397 ecode1 = SWIG_AsVal_int(obj0, &val1);
5398 if (!SWIG_IsOK(ecode1)) {
5399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5400 }
5401 arg1 = static_cast< int >(val1);
5402 }
5403 if (obj1) {
5404 ecode2 = SWIG_AsVal_int(obj1, &val2);
5405 if (!SWIG_IsOK(ecode2)) {
5406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5407 }
5408 arg2 = static_cast< int >(val2);
5409 }
5410 {
5411 PyThreadState* __tstate = wxPyBeginAllowThreads();
5412 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5413 wxPyEndAllowThreads(__tstate);
5414 if (PyErr_Occurred()) SWIG_fail;
5415 }
5416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5417 return resultobj;
5418 fail:
5419 return NULL;
5420 }
5421
5422
5423 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 PyObject *obj;
5425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5426 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5427 return SWIG_Py_Void();
5428 }
5429
5430 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5431 return SWIG_Python_InitShadowInstance(args);
5432 }
5433
5434 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5435 PyObject *resultobj = 0;
5436 int arg1 = (int) -1 ;
5437 int arg2 = (int) -1 ;
5438 wxGridCellFloatEditor *result = 0 ;
5439 int val1 ;
5440 int ecode1 = 0 ;
5441 int val2 ;
5442 int ecode2 = 0 ;
5443 PyObject * obj0 = 0 ;
5444 PyObject * obj1 = 0 ;
5445 char * kwnames[] = {
5446 (char *) "width",(char *) "precision", NULL
5447 };
5448
5449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5450 if (obj0) {
5451 ecode1 = SWIG_AsVal_int(obj0, &val1);
5452 if (!SWIG_IsOK(ecode1)) {
5453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5454 }
5455 arg1 = static_cast< int >(val1);
5456 }
5457 if (obj1) {
5458 ecode2 = SWIG_AsVal_int(obj1, &val2);
5459 if (!SWIG_IsOK(ecode2)) {
5460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5461 }
5462 arg2 = static_cast< int >(val2);
5463 }
5464 {
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5467 wxPyEndAllowThreads(__tstate);
5468 if (PyErr_Occurred()) SWIG_fail;
5469 }
5470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5471 return resultobj;
5472 fail:
5473 return NULL;
5474 }
5475
5476
5477 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5478 PyObject *obj;
5479 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5480 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5481 return SWIG_Py_Void();
5482 }
5483
5484 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5485 return SWIG_Python_InitShadowInstance(args);
5486 }
5487
5488 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5489 PyObject *resultobj = 0;
5490 wxGridCellBoolEditor *result = 0 ;
5491
5492 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *resultobj = 0;
5508 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5509 wxString result;
5510 void *argp1 = 0 ;
5511 int res1 = 0 ;
5512 PyObject *swig_obj[1] ;
5513
5514 if (!args) SWIG_fail;
5515 swig_obj[0] = args;
5516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5517 if (!SWIG_IsOK(res1)) {
5518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5519 }
5520 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5521 {
5522 PyThreadState* __tstate = wxPyBeginAllowThreads();
5523 result = (arg1)->GetValue();
5524 wxPyEndAllowThreads(__tstate);
5525 if (PyErr_Occurred()) SWIG_fail;
5526 }
5527 {
5528 #if wxUSE_UNICODE
5529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5530 #else
5531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5532 #endif
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5541 PyObject *obj;
5542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5543 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5544 return SWIG_Py_Void();
5545 }
5546
5547 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5548 return SWIG_Python_InitShadowInstance(args);
5549 }
5550
5551 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5552 PyObject *resultobj = 0;
5553 int arg1 = (int) 0 ;
5554 wxString *arg2 = (wxString *) NULL ;
5555 bool arg3 = (bool) false ;
5556 wxGridCellChoiceEditor *result = 0 ;
5557 bool val3 ;
5558 int ecode3 = 0 ;
5559 PyObject * obj0 = 0 ;
5560 PyObject * obj1 = 0 ;
5561 char * kwnames[] = {
5562 (char *) "choices",(char *) "allowOthers", NULL
5563 };
5564
5565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5566 if (obj0) {
5567 {
5568 arg1 = PyList_Size(obj0);
5569 arg2 = wxString_LIST_helper(obj0);
5570 if (arg2 == NULL) SWIG_fail;
5571 }
5572 }
5573 if (obj1) {
5574 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5575 if (!SWIG_IsOK(ecode3)) {
5576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5577 }
5578 arg3 = static_cast< bool >(val3);
5579 }
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5587 {
5588 if (arg2) delete [] arg2;
5589 }
5590 return resultobj;
5591 fail:
5592 {
5593 if (arg2) delete [] arg2;
5594 }
5595 return NULL;
5596 }
5597
5598
5599 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 PyObject *resultobj = 0;
5601 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5602 wxString result;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 PyObject *swig_obj[1] ;
5606
5607 if (!args) SWIG_fail;
5608 swig_obj[0] = args;
5609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5610 if (!SWIG_IsOK(res1)) {
5611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5612 }
5613 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5614 {
5615 PyThreadState* __tstate = wxPyBeginAllowThreads();
5616 result = (arg1)->GetValue();
5617 wxPyEndAllowThreads(__tstate);
5618 if (PyErr_Occurred()) SWIG_fail;
5619 }
5620 {
5621 #if wxUSE_UNICODE
5622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5623 #else
5624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5625 #endif
5626 }
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5634 PyObject *obj;
5635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5636 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5637 return SWIG_Py_Void();
5638 }
5639
5640 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5641 return SWIG_Python_InitShadowInstance(args);
5642 }
5643
5644 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5645 PyObject *resultobj = 0;
5646 wxString const &arg1_defvalue = wxPyEmptyString ;
5647 wxString *arg1 = (wxString *) &arg1_defvalue ;
5648 wxGridCellEnumEditor *result = 0 ;
5649 bool temp1 = false ;
5650 PyObject * obj0 = 0 ;
5651 char * kwnames[] = {
5652 (char *) "choices", NULL
5653 };
5654
5655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5656 if (obj0) {
5657 {
5658 arg1 = wxString_in_helper(obj0);
5659 if (arg1 == NULL) SWIG_fail;
5660 temp1 = true;
5661 }
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5670 {
5671 if (temp1)
5672 delete arg1;
5673 }
5674 return resultobj;
5675 fail:
5676 {
5677 if (temp1)
5678 delete arg1;
5679 }
5680 return NULL;
5681 }
5682
5683
5684 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5685 PyObject *obj;
5686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5687 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5688 return SWIG_Py_Void();
5689 }
5690
5691 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5692 return SWIG_Python_InitShadowInstance(args);
5693 }
5694
5695 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5696 PyObject *resultobj = 0;
5697 wxGridCellAutoWrapStringEditor *result = 0 ;
5698
5699 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5700 {
5701 PyThreadState* __tstate = wxPyBeginAllowThreads();
5702 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5714 PyObject *obj;
5715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5716 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5717 return SWIG_Py_Void();
5718 }
5719
5720 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5721 return SWIG_Python_InitShadowInstance(args);
5722 }
5723
5724 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5725 PyObject *resultobj = 0;
5726 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5727 PyObject *arg2 = (PyObject *) 0 ;
5728 void *argp1 = 0 ;
5729 int res1 = 0 ;
5730 PyObject * obj0 = 0 ;
5731 PyObject * obj1 = 0 ;
5732 char * kwnames[] = {
5733 (char *) "self",(char *) "_self", NULL
5734 };
5735
5736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5738 if (!SWIG_IsOK(res1)) {
5739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5740 }
5741 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5742 arg2 = obj1;
5743 {
5744 PyThreadState* __tstate = wxPyBeginAllowThreads();
5745 wxGridCellAttr__setOORInfo(arg1,arg2);
5746 wxPyEndAllowThreads(__tstate);
5747 if (PyErr_Occurred()) SWIG_fail;
5748 }
5749 resultobj = SWIG_Py_Void();
5750 return resultobj;
5751 fail:
5752 return NULL;
5753 }
5754
5755
5756 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5757 PyObject *resultobj = 0;
5758 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5759 wxGridCellAttr *result = 0 ;
5760 void *argp1 = 0 ;
5761 int res1 = 0 ;
5762 PyObject * obj0 = 0 ;
5763 char * kwnames[] = {
5764 (char *) "attrDefault", NULL
5765 };
5766
5767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5768 if (obj0) {
5769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5770 if (!SWIG_IsOK(res1)) {
5771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5772 }
5773 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5774 }
5775 {
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 {
5782 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5783 }
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5791 PyObject *resultobj = 0;
5792 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5793 void *argp1 = 0 ;
5794 int res1 = 0 ;
5795 PyObject *swig_obj[1] ;
5796
5797 if (!args) SWIG_fail;
5798 swig_obj[0] = args;
5799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5800 if (!SWIG_IsOK(res1)) {
5801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5802 }
5803 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5804 {
5805 PyThreadState* __tstate = wxPyBeginAllowThreads();
5806 delete_wxGridCellAttr(arg1);
5807
5808 wxPyEndAllowThreads(__tstate);
5809 if (PyErr_Occurred()) SWIG_fail;
5810 }
5811 resultobj = SWIG_Py_Void();
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5819 PyObject *resultobj = 0;
5820 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5821 wxGridCellAttr *result = 0 ;
5822 void *argp1 = 0 ;
5823 int res1 = 0 ;
5824 PyObject *swig_obj[1] ;
5825
5826 if (!args) SWIG_fail;
5827 swig_obj[0] = args;
5828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5831 }
5832 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5833 {
5834 PyThreadState* __tstate = wxPyBeginAllowThreads();
5835 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 {
5840 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5841 }
5842 return resultobj;
5843 fail:
5844 return NULL;
5845 }
5846
5847
5848 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5849 PyObject *resultobj = 0;
5850 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5851 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 void *argp2 = 0 ;
5855 int res2 = 0 ;
5856 PyObject * obj0 = 0 ;
5857 PyObject * obj1 = 0 ;
5858 char * kwnames[] = {
5859 (char *) "self",(char *) "mergefrom", NULL
5860 };
5861
5862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5864 if (!SWIG_IsOK(res1)) {
5865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5866 }
5867 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5868 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5869 if (!SWIG_IsOK(res2)) {
5870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5871 }
5872 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5873 {
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 (arg1)->MergeWith(arg2);
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 resultobj = SWIG_Py_Void();
5880 return resultobj;
5881 fail:
5882 return NULL;
5883 }
5884
5885
5886 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5887 PyObject *resultobj = 0;
5888 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 PyObject *swig_obj[1] ;
5892
5893 if (!args) SWIG_fail;
5894 swig_obj[0] = args;
5895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5896 if (!SWIG_IsOK(res1)) {
5897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5898 }
5899 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5900 {
5901 PyThreadState* __tstate = wxPyBeginAllowThreads();
5902 (arg1)->IncRef();
5903 wxPyEndAllowThreads(__tstate);
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 resultobj = SWIG_Py_Void();
5907 return resultobj;
5908 fail:
5909 return NULL;
5910 }
5911
5912
5913 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5914 PyObject *resultobj = 0;
5915 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5916 void *argp1 = 0 ;
5917 int res1 = 0 ;
5918 PyObject *swig_obj[1] ;
5919
5920 if (!args) SWIG_fail;
5921 swig_obj[0] = args;
5922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5923 if (!SWIG_IsOK(res1)) {
5924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5925 }
5926 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5927 {
5928 PyThreadState* __tstate = wxPyBeginAllowThreads();
5929 (arg1)->DecRef();
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 resultobj = SWIG_Py_Void();
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj = 0;
5942 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5943 wxColour *arg2 = 0 ;
5944 void *argp1 = 0 ;
5945 int res1 = 0 ;
5946 wxColour temp2 ;
5947 PyObject * obj0 = 0 ;
5948 PyObject * obj1 = 0 ;
5949 char * kwnames[] = {
5950 (char *) "self",(char *) "colText", NULL
5951 };
5952
5953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5955 if (!SWIG_IsOK(res1)) {
5956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5957 }
5958 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5959 {
5960 arg2 = &temp2;
5961 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5962 }
5963 {
5964 PyThreadState* __tstate = wxPyBeginAllowThreads();
5965 (arg1)->SetTextColour((wxColour const &)*arg2);
5966 wxPyEndAllowThreads(__tstate);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 resultobj = SWIG_Py_Void();
5970 return resultobj;
5971 fail:
5972 return NULL;
5973 }
5974
5975
5976 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5977 PyObject *resultobj = 0;
5978 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5979 wxColour *arg2 = 0 ;
5980 void *argp1 = 0 ;
5981 int res1 = 0 ;
5982 wxColour temp2 ;
5983 PyObject * obj0 = 0 ;
5984 PyObject * obj1 = 0 ;
5985 char * kwnames[] = {
5986 (char *) "self",(char *) "colBack", NULL
5987 };
5988
5989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5991 if (!SWIG_IsOK(res1)) {
5992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5993 }
5994 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5995 {
5996 arg2 = &temp2;
5997 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5998 }
5999 {
6000 PyThreadState* __tstate = wxPyBeginAllowThreads();
6001 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6002 wxPyEndAllowThreads(__tstate);
6003 if (PyErr_Occurred()) SWIG_fail;
6004 }
6005 resultobj = SWIG_Py_Void();
6006 return resultobj;
6007 fail:
6008 return NULL;
6009 }
6010
6011
6012 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6013 PyObject *resultobj = 0;
6014 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6015 wxFont *arg2 = 0 ;
6016 void *argp1 = 0 ;
6017 int res1 = 0 ;
6018 void *argp2 = 0 ;
6019 int res2 = 0 ;
6020 PyObject * obj0 = 0 ;
6021 PyObject * obj1 = 0 ;
6022 char * kwnames[] = {
6023 (char *) "self",(char *) "font", NULL
6024 };
6025
6026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6028 if (!SWIG_IsOK(res1)) {
6029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6030 }
6031 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6032 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6033 if (!SWIG_IsOK(res2)) {
6034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6035 }
6036 if (!argp2) {
6037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6038 }
6039 arg2 = reinterpret_cast< wxFont * >(argp2);
6040 {
6041 PyThreadState* __tstate = wxPyBeginAllowThreads();
6042 (arg1)->SetFont((wxFont const &)*arg2);
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 resultobj = SWIG_Py_Void();
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj = 0;
6055 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6056 int arg2 ;
6057 int arg3 ;
6058 void *argp1 = 0 ;
6059 int res1 = 0 ;
6060 int val2 ;
6061 int ecode2 = 0 ;
6062 int val3 ;
6063 int ecode3 = 0 ;
6064 PyObject * obj0 = 0 ;
6065 PyObject * obj1 = 0 ;
6066 PyObject * obj2 = 0 ;
6067 char * kwnames[] = {
6068 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6069 };
6070
6071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6073 if (!SWIG_IsOK(res1)) {
6074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6075 }
6076 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6077 ecode2 = SWIG_AsVal_int(obj1, &val2);
6078 if (!SWIG_IsOK(ecode2)) {
6079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6080 }
6081 arg2 = static_cast< int >(val2);
6082 ecode3 = SWIG_AsVal_int(obj2, &val3);
6083 if (!SWIG_IsOK(ecode3)) {
6084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6085 }
6086 arg3 = static_cast< int >(val3);
6087 {
6088 PyThreadState* __tstate = wxPyBeginAllowThreads();
6089 (arg1)->SetAlignment(arg2,arg3);
6090 wxPyEndAllowThreads(__tstate);
6091 if (PyErr_Occurred()) SWIG_fail;
6092 }
6093 resultobj = SWIG_Py_Void();
6094 return resultobj;
6095 fail:
6096 return NULL;
6097 }
6098
6099
6100 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj = 0;
6102 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6103 int arg2 ;
6104 int arg3 ;
6105 void *argp1 = 0 ;
6106 int res1 = 0 ;
6107 int val2 ;
6108 int ecode2 = 0 ;
6109 int val3 ;
6110 int ecode3 = 0 ;
6111 PyObject * obj0 = 0 ;
6112 PyObject * obj1 = 0 ;
6113 PyObject * obj2 = 0 ;
6114 char * kwnames[] = {
6115 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6116 };
6117
6118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6120 if (!SWIG_IsOK(res1)) {
6121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6122 }
6123 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6124 ecode2 = SWIG_AsVal_int(obj1, &val2);
6125 if (!SWIG_IsOK(ecode2)) {
6126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6127 }
6128 arg2 = static_cast< int >(val2);
6129 ecode3 = SWIG_AsVal_int(obj2, &val3);
6130 if (!SWIG_IsOK(ecode3)) {
6131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6132 }
6133 arg3 = static_cast< int >(val3);
6134 {
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 (arg1)->SetSize(arg2,arg3);
6137 wxPyEndAllowThreads(__tstate);
6138 if (PyErr_Occurred()) SWIG_fail;
6139 }
6140 resultobj = SWIG_Py_Void();
6141 return resultobj;
6142 fail:
6143 return NULL;
6144 }
6145
6146
6147 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6148 PyObject *resultobj = 0;
6149 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6150 bool arg2 = (bool) true ;
6151 void *argp1 = 0 ;
6152 int res1 = 0 ;
6153 bool val2 ;
6154 int ecode2 = 0 ;
6155 PyObject * obj0 = 0 ;
6156 PyObject * obj1 = 0 ;
6157 char * kwnames[] = {
6158 (char *) "self",(char *) "allow", NULL
6159 };
6160
6161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6163 if (!SWIG_IsOK(res1)) {
6164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6165 }
6166 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6167 if (obj1) {
6168 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6169 if (!SWIG_IsOK(ecode2)) {
6170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6171 }
6172 arg2 = static_cast< bool >(val2);
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 (arg1)->SetOverflow(arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_Py_Void();
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6190 bool arg2 = (bool) true ;
6191 void *argp1 = 0 ;
6192 int res1 = 0 ;
6193 bool val2 ;
6194 int ecode2 = 0 ;
6195 PyObject * obj0 = 0 ;
6196 PyObject * obj1 = 0 ;
6197 char * kwnames[] = {
6198 (char *) "self",(char *) "isReadOnly", NULL
6199 };
6200
6201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6203 if (!SWIG_IsOK(res1)) {
6204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6205 }
6206 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6207 if (obj1) {
6208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6209 if (!SWIG_IsOK(ecode2)) {
6210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6211 }
6212 arg2 = static_cast< bool >(val2);
6213 }
6214 {
6215 PyThreadState* __tstate = wxPyBeginAllowThreads();
6216 (arg1)->SetReadOnly(arg2);
6217 wxPyEndAllowThreads(__tstate);
6218 if (PyErr_Occurred()) SWIG_fail;
6219 }
6220 resultobj = SWIG_Py_Void();
6221 return resultobj;
6222 fail:
6223 return NULL;
6224 }
6225
6226
6227 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6228 PyObject *resultobj = 0;
6229 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6230 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6231 void *argp1 = 0 ;
6232 int res1 = 0 ;
6233 void *argp2 = 0 ;
6234 int res2 = 0 ;
6235 PyObject * obj0 = 0 ;
6236 PyObject * obj1 = 0 ;
6237 char * kwnames[] = {
6238 (char *) "self",(char *) "renderer", NULL
6239 };
6240
6241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6243 if (!SWIG_IsOK(res1)) {
6244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6245 }
6246 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6248 if (!SWIG_IsOK(res2)) {
6249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6250 }
6251 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6252 {
6253 PyThreadState* __tstate = wxPyBeginAllowThreads();
6254 (arg1)->SetRenderer(arg2);
6255 wxPyEndAllowThreads(__tstate);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 resultobj = SWIG_Py_Void();
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj = 0;
6267 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6268 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6269 void *argp1 = 0 ;
6270 int res1 = 0 ;
6271 void *argp2 = 0 ;
6272 int res2 = 0 ;
6273 PyObject * obj0 = 0 ;
6274 PyObject * obj1 = 0 ;
6275 char * kwnames[] = {
6276 (char *) "self",(char *) "editor", NULL
6277 };
6278
6279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6281 if (!SWIG_IsOK(res1)) {
6282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6283 }
6284 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6286 if (!SWIG_IsOK(res2)) {
6287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6288 }
6289 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6290 {
6291 PyThreadState* __tstate = wxPyBeginAllowThreads();
6292 (arg1)->SetEditor(arg2);
6293 wxPyEndAllowThreads(__tstate);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 resultobj = SWIG_Py_Void();
6297 return resultobj;
6298 fail:
6299 return NULL;
6300 }
6301
6302
6303 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj = 0;
6305 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6306 wxGridCellAttr::wxAttrKind arg2 ;
6307 void *argp1 = 0 ;
6308 int res1 = 0 ;
6309 int val2 ;
6310 int ecode2 = 0 ;
6311 PyObject * obj0 = 0 ;
6312 PyObject * obj1 = 0 ;
6313 char * kwnames[] = {
6314 (char *) "self",(char *) "kind", NULL
6315 };
6316
6317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6319 if (!SWIG_IsOK(res1)) {
6320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6321 }
6322 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6323 ecode2 = SWIG_AsVal_int(obj1, &val2);
6324 if (!SWIG_IsOK(ecode2)) {
6325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6326 }
6327 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6328 {
6329 PyThreadState* __tstate = wxPyBeginAllowThreads();
6330 (arg1)->SetKind(arg2);
6331 wxPyEndAllowThreads(__tstate);
6332 if (PyErr_Occurred()) SWIG_fail;
6333 }
6334 resultobj = SWIG_Py_Void();
6335 return resultobj;
6336 fail:
6337 return NULL;
6338 }
6339
6340
6341 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6342 PyObject *resultobj = 0;
6343 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6344 bool result;
6345 void *argp1 = 0 ;
6346 int res1 = 0 ;
6347 PyObject *swig_obj[1] ;
6348
6349 if (!args) SWIG_fail;
6350 swig_obj[0] = args;
6351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6352 if (!SWIG_IsOK(res1)) {
6353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6354 }
6355 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6356 {
6357 PyThreadState* __tstate = wxPyBeginAllowThreads();
6358 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6359 wxPyEndAllowThreads(__tstate);
6360 if (PyErr_Occurred()) SWIG_fail;
6361 }
6362 {
6363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6364 }
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6372 PyObject *resultobj = 0;
6373 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6374 bool result;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 PyObject *swig_obj[1] ;
6378
6379 if (!args) SWIG_fail;
6380 swig_obj[0] = args;
6381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6382 if (!SWIG_IsOK(res1)) {
6383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6384 }
6385 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 {
6393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6394 }
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6402 PyObject *resultobj = 0;
6403 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6404 bool result;
6405 void *argp1 = 0 ;
6406 int res1 = 0 ;
6407 PyObject *swig_obj[1] ;
6408
6409 if (!args) SWIG_fail;
6410 swig_obj[0] = args;
6411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6412 if (!SWIG_IsOK(res1)) {
6413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6414 }
6415 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6416 {
6417 PyThreadState* __tstate = wxPyBeginAllowThreads();
6418 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6419 wxPyEndAllowThreads(__tstate);
6420 if (PyErr_Occurred()) SWIG_fail;
6421 }
6422 {
6423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6424 }
6425 return resultobj;
6426 fail:
6427 return NULL;
6428 }
6429
6430
6431 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6432 PyObject *resultobj = 0;
6433 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6434 bool result;
6435 void *argp1 = 0 ;
6436 int res1 = 0 ;
6437 PyObject *swig_obj[1] ;
6438
6439 if (!args) SWIG_fail;
6440 swig_obj[0] = args;
6441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6442 if (!SWIG_IsOK(res1)) {
6443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6444 }
6445 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6446 {
6447 PyThreadState* __tstate = wxPyBeginAllowThreads();
6448 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 {
6453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6454 }
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6462 PyObject *resultobj = 0;
6463 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6464 bool result;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 PyObject *swig_obj[1] ;
6468
6469 if (!args) SWIG_fail;
6470 swig_obj[0] = args;
6471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6474 }
6475 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6479 wxPyEndAllowThreads(__tstate);
6480 if (PyErr_Occurred()) SWIG_fail;
6481 }
6482 {
6483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6484 }
6485 return resultobj;
6486 fail:
6487 return NULL;
6488 }
6489
6490
6491 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6492 PyObject *resultobj = 0;
6493 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6494 bool result;
6495 void *argp1 = 0 ;
6496 int res1 = 0 ;
6497 PyObject *swig_obj[1] ;
6498
6499 if (!args) SWIG_fail;
6500 swig_obj[0] = args;
6501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6502 if (!SWIG_IsOK(res1)) {
6503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6504 }
6505 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6506 {
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 {
6513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6514 }
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6522 PyObject *resultobj = 0;
6523 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6524 bool result;
6525 void *argp1 = 0 ;
6526 int res1 = 0 ;
6527 PyObject *swig_obj[1] ;
6528
6529 if (!args) SWIG_fail;
6530 swig_obj[0] = args;
6531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6532 if (!SWIG_IsOK(res1)) {
6533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6534 }
6535 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6536 {
6537 PyThreadState* __tstate = wxPyBeginAllowThreads();
6538 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6539 wxPyEndAllowThreads(__tstate);
6540 if (PyErr_Occurred()) SWIG_fail;
6541 }
6542 {
6543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6544 }
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6552 PyObject *resultobj = 0;
6553 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6554 bool result;
6555 void *argp1 = 0 ;
6556 int res1 = 0 ;
6557 PyObject *swig_obj[1] ;
6558
6559 if (!args) SWIG_fail;
6560 swig_obj[0] = args;
6561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6562 if (!SWIG_IsOK(res1)) {
6563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6564 }
6565 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6566 {
6567 PyThreadState* __tstate = wxPyBeginAllowThreads();
6568 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6569 wxPyEndAllowThreads(__tstate);
6570 if (PyErr_Occurred()) SWIG_fail;
6571 }
6572 {
6573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6574 }
6575 return resultobj;
6576 fail:
6577 return NULL;
6578 }
6579
6580
6581 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6582 PyObject *resultobj = 0;
6583 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6584 wxColour result;
6585 void *argp1 = 0 ;
6586 int res1 = 0 ;
6587 PyObject *swig_obj[1] ;
6588
6589 if (!args) SWIG_fail;
6590 swig_obj[0] = args;
6591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6592 if (!SWIG_IsOK(res1)) {
6593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6594 }
6595 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6596 {
6597 PyThreadState* __tstate = wxPyBeginAllowThreads();
6598 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6599 wxPyEndAllowThreads(__tstate);
6600 if (PyErr_Occurred()) SWIG_fail;
6601 }
6602 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6610 PyObject *resultobj = 0;
6611 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6612 wxColour result;
6613 void *argp1 = 0 ;
6614 int res1 = 0 ;
6615 PyObject *swig_obj[1] ;
6616
6617 if (!args) SWIG_fail;
6618 swig_obj[0] = args;
6619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6620 if (!SWIG_IsOK(res1)) {
6621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6622 }
6623 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6627 wxPyEndAllowThreads(__tstate);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6631 return resultobj;
6632 fail:
6633 return NULL;
6634 }
6635
6636
6637 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6638 PyObject *resultobj = 0;
6639 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6640 wxFont result;
6641 void *argp1 = 0 ;
6642 int res1 = 0 ;
6643 PyObject *swig_obj[1] ;
6644
6645 if (!args) SWIG_fail;
6646 swig_obj[0] = args;
6647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6650 }
6651 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6652 {
6653 PyThreadState* __tstate = wxPyBeginAllowThreads();
6654 result = ((wxGridCellAttr const *)arg1)->GetFont();
6655 wxPyEndAllowThreads(__tstate);
6656 if (PyErr_Occurred()) SWIG_fail;
6657 }
6658 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6659 return resultobj;
6660 fail:
6661 return NULL;
6662 }
6663
6664
6665 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6666 PyObject *resultobj = 0;
6667 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6668 int *arg2 = (int *) 0 ;
6669 int *arg3 = (int *) 0 ;
6670 void *argp1 = 0 ;
6671 int res1 = 0 ;
6672 int temp2 ;
6673 int res2 = SWIG_TMPOBJ ;
6674 int temp3 ;
6675 int res3 = SWIG_TMPOBJ ;
6676 PyObject *swig_obj[1] ;
6677
6678 arg2 = &temp2;
6679 arg3 = &temp3;
6680 if (!args) SWIG_fail;
6681 swig_obj[0] = args;
6682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6683 if (!SWIG_IsOK(res1)) {
6684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6685 }
6686 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6687 {
6688 PyThreadState* __tstate = wxPyBeginAllowThreads();
6689 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6690 wxPyEndAllowThreads(__tstate);
6691 if (PyErr_Occurred()) SWIG_fail;
6692 }
6693 resultobj = SWIG_Py_Void();
6694 if (SWIG_IsTmpObj(res2)) {
6695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6696 } else {
6697 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6699 }
6700 if (SWIG_IsTmpObj(res3)) {
6701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6702 } else {
6703 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6705 }
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6713 PyObject *resultobj = 0;
6714 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6715 int *arg2 = (int *) 0 ;
6716 int *arg3 = (int *) 0 ;
6717 void *argp1 = 0 ;
6718 int res1 = 0 ;
6719 int temp2 ;
6720 int res2 = SWIG_TMPOBJ ;
6721 int temp3 ;
6722 int res3 = SWIG_TMPOBJ ;
6723 PyObject *swig_obj[1] ;
6724
6725 arg2 = &temp2;
6726 arg3 = &temp3;
6727 if (!args) SWIG_fail;
6728 swig_obj[0] = args;
6729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6730 if (!SWIG_IsOK(res1)) {
6731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6732 }
6733 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6734 {
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 resultobj = SWIG_Py_Void();
6741 if (SWIG_IsTmpObj(res2)) {
6742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6743 } else {
6744 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6746 }
6747 if (SWIG_IsTmpObj(res3)) {
6748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6749 } else {
6750 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6752 }
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6760 PyObject *resultobj = 0;
6761 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6762 bool result;
6763 void *argp1 = 0 ;
6764 int res1 = 0 ;
6765 PyObject *swig_obj[1] ;
6766
6767 if (!args) SWIG_fail;
6768 swig_obj[0] = args;
6769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6770 if (!SWIG_IsOK(res1)) {
6771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6772 }
6773 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6774 {
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6777 wxPyEndAllowThreads(__tstate);
6778 if (PyErr_Occurred()) SWIG_fail;
6779 }
6780 {
6781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6782 }
6783 return resultobj;
6784 fail:
6785 return NULL;
6786 }
6787
6788
6789 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6790 PyObject *resultobj = 0;
6791 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6792 wxGrid *arg2 = (wxGrid *) 0 ;
6793 int arg3 ;
6794 int arg4 ;
6795 wxGridCellRenderer *result = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 void *argp2 = 0 ;
6799 int res2 = 0 ;
6800 int val3 ;
6801 int ecode3 = 0 ;
6802 int val4 ;
6803 int ecode4 = 0 ;
6804 PyObject * obj0 = 0 ;
6805 PyObject * obj1 = 0 ;
6806 PyObject * obj2 = 0 ;
6807 PyObject * obj3 = 0 ;
6808 char * kwnames[] = {
6809 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6810 };
6811
6812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6814 if (!SWIG_IsOK(res1)) {
6815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6816 }
6817 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6818 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6819 if (!SWIG_IsOK(res2)) {
6820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6821 }
6822 arg2 = reinterpret_cast< wxGrid * >(argp2);
6823 ecode3 = SWIG_AsVal_int(obj2, &val3);
6824 if (!SWIG_IsOK(ecode3)) {
6825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6826 }
6827 arg3 = static_cast< int >(val3);
6828 ecode4 = SWIG_AsVal_int(obj3, &val4);
6829 if (!SWIG_IsOK(ecode4)) {
6830 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6831 }
6832 arg4 = static_cast< int >(val4);
6833 {
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 {
6840 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6841 }
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj = 0;
6850 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6851 wxGrid *arg2 = (wxGrid *) 0 ;
6852 int arg3 ;
6853 int arg4 ;
6854 wxGridCellEditor *result = 0 ;
6855 void *argp1 = 0 ;
6856 int res1 = 0 ;
6857 void *argp2 = 0 ;
6858 int res2 = 0 ;
6859 int val3 ;
6860 int ecode3 = 0 ;
6861 int val4 ;
6862 int ecode4 = 0 ;
6863 PyObject * obj0 = 0 ;
6864 PyObject * obj1 = 0 ;
6865 PyObject * obj2 = 0 ;
6866 PyObject * obj3 = 0 ;
6867 char * kwnames[] = {
6868 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6869 };
6870
6871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6873 if (!SWIG_IsOK(res1)) {
6874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6875 }
6876 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6877 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6878 if (!SWIG_IsOK(res2)) {
6879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6880 }
6881 arg2 = reinterpret_cast< wxGrid * >(argp2);
6882 ecode3 = SWIG_AsVal_int(obj2, &val3);
6883 if (!SWIG_IsOK(ecode3)) {
6884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6885 }
6886 arg3 = static_cast< int >(val3);
6887 ecode4 = SWIG_AsVal_int(obj3, &val4);
6888 if (!SWIG_IsOK(ecode4)) {
6889 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6890 }
6891 arg4 = static_cast< int >(val4);
6892 {
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6895 wxPyEndAllowThreads(__tstate);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 {
6899 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6900 }
6901 return resultobj;
6902 fail:
6903 return NULL;
6904 }
6905
6906
6907 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6908 PyObject *resultobj = 0;
6909 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6910 bool result;
6911 void *argp1 = 0 ;
6912 int res1 = 0 ;
6913 PyObject *swig_obj[1] ;
6914
6915 if (!args) SWIG_fail;
6916 swig_obj[0] = args;
6917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6918 if (!SWIG_IsOK(res1)) {
6919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6920 }
6921 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 {
6929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6930 }
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6938 PyObject *resultobj = 0;
6939 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6940 wxGridCellAttr::wxAttrKind result;
6941 void *argp1 = 0 ;
6942 int res1 = 0 ;
6943 PyObject *swig_obj[1] ;
6944
6945 if (!args) SWIG_fail;
6946 swig_obj[0] = args;
6947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6948 if (!SWIG_IsOK(res1)) {
6949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6950 }
6951 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6952 {
6953 PyThreadState* __tstate = wxPyBeginAllowThreads();
6954 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_From_int(static_cast< int >(result));
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj = 0;
6967 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6968 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6969 void *argp1 = 0 ;
6970 int res1 = 0 ;
6971 void *argp2 = 0 ;
6972 int res2 = 0 ;
6973 PyObject * obj0 = 0 ;
6974 PyObject * obj1 = 0 ;
6975 char * kwnames[] = {
6976 (char *) "self",(char *) "defAttr", NULL
6977 };
6978
6979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6981 if (!SWIG_IsOK(res1)) {
6982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6983 }
6984 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6986 if (!SWIG_IsOK(res2)) {
6987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6988 }
6989 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6990 {
6991 PyThreadState* __tstate = wxPyBeginAllowThreads();
6992 (arg1)->SetDefAttr(arg2);
6993 wxPyEndAllowThreads(__tstate);
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 resultobj = SWIG_Py_Void();
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7004 PyObject *obj;
7005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7006 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7007 return SWIG_Py_Void();
7008 }
7009
7010 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7011 return SWIG_Python_InitShadowInstance(args);
7012 }
7013
7014 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7015 PyObject *resultobj = 0;
7016 wxGridCellAttrProvider *result = 0 ;
7017
7018 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7019 {
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 {
7026 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7027 }
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj = 0;
7036 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7037 PyObject *arg2 = (PyObject *) 0 ;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 PyObject * obj0 = 0 ;
7041 PyObject * obj1 = 0 ;
7042 char * kwnames[] = {
7043 (char *) "self",(char *) "_self", NULL
7044 };
7045
7046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7048 if (!SWIG_IsOK(res1)) {
7049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7050 }
7051 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7052 arg2 = obj1;
7053 {
7054 PyThreadState* __tstate = wxPyBeginAllowThreads();
7055 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7056 wxPyEndAllowThreads(__tstate);
7057 if (PyErr_Occurred()) SWIG_fail;
7058 }
7059 resultobj = SWIG_Py_Void();
7060 return resultobj;
7061 fail:
7062 return NULL;
7063 }
7064
7065
7066 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj = 0;
7068 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7069 int arg2 ;
7070 int arg3 ;
7071 wxGridCellAttr::wxAttrKind arg4 ;
7072 wxGridCellAttr *result = 0 ;
7073 void *argp1 = 0 ;
7074 int res1 = 0 ;
7075 int val2 ;
7076 int ecode2 = 0 ;
7077 int val3 ;
7078 int ecode3 = 0 ;
7079 int val4 ;
7080 int ecode4 = 0 ;
7081 PyObject * obj0 = 0 ;
7082 PyObject * obj1 = 0 ;
7083 PyObject * obj2 = 0 ;
7084 PyObject * obj3 = 0 ;
7085 char * kwnames[] = {
7086 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7087 };
7088
7089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7091 if (!SWIG_IsOK(res1)) {
7092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7093 }
7094 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7095 ecode2 = SWIG_AsVal_int(obj1, &val2);
7096 if (!SWIG_IsOK(ecode2)) {
7097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7098 }
7099 arg2 = static_cast< int >(val2);
7100 ecode3 = SWIG_AsVal_int(obj2, &val3);
7101 if (!SWIG_IsOK(ecode3)) {
7102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7103 }
7104 arg3 = static_cast< int >(val3);
7105 ecode4 = SWIG_AsVal_int(obj3, &val4);
7106 if (!SWIG_IsOK(ecode4)) {
7107 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7108 }
7109 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7110 {
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 {
7117 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7118 }
7119 return resultobj;
7120 fail:
7121 return NULL;
7122 }
7123
7124
7125 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7126 PyObject *resultobj = 0;
7127 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7128 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7129 int arg3 ;
7130 int arg4 ;
7131 void *argp1 = 0 ;
7132 int res1 = 0 ;
7133 void *argp2 = 0 ;
7134 int res2 = 0 ;
7135 int val3 ;
7136 int ecode3 = 0 ;
7137 int val4 ;
7138 int ecode4 = 0 ;
7139 PyObject * obj0 = 0 ;
7140 PyObject * obj1 = 0 ;
7141 PyObject * obj2 = 0 ;
7142 PyObject * obj3 = 0 ;
7143 char * kwnames[] = {
7144 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7145 };
7146
7147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7149 if (!SWIG_IsOK(res1)) {
7150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7151 }
7152 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7154 if (!SWIG_IsOK(res2)) {
7155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7156 }
7157 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7158 ecode3 = SWIG_AsVal_int(obj2, &val3);
7159 if (!SWIG_IsOK(ecode3)) {
7160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7161 }
7162 arg3 = static_cast< int >(val3);
7163 ecode4 = SWIG_AsVal_int(obj3, &val4);
7164 if (!SWIG_IsOK(ecode4)) {
7165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7166 }
7167 arg4 = static_cast< int >(val4);
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 (arg1)->SetAttr(arg2,arg3,arg4);
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 resultobj = SWIG_Py_Void();
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7182 PyObject *resultobj = 0;
7183 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7184 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7185 int arg3 ;
7186 void *argp1 = 0 ;
7187 int res1 = 0 ;
7188 void *argp2 = 0 ;
7189 int res2 = 0 ;
7190 int val3 ;
7191 int ecode3 = 0 ;
7192 PyObject * obj0 = 0 ;
7193 PyObject * obj1 = 0 ;
7194 PyObject * obj2 = 0 ;
7195 char * kwnames[] = {
7196 (char *) "self",(char *) "attr",(char *) "row", NULL
7197 };
7198
7199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7201 if (!SWIG_IsOK(res1)) {
7202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7203 }
7204 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7206 if (!SWIG_IsOK(res2)) {
7207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7208 }
7209 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7210 ecode3 = SWIG_AsVal_int(obj2, &val3);
7211 if (!SWIG_IsOK(ecode3)) {
7212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7213 }
7214 arg3 = static_cast< int >(val3);
7215 {
7216 PyThreadState* __tstate = wxPyBeginAllowThreads();
7217 (arg1)->SetRowAttr(arg2,arg3);
7218 wxPyEndAllowThreads(__tstate);
7219 if (PyErr_Occurred()) SWIG_fail;
7220 }
7221 resultobj = SWIG_Py_Void();
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj = 0;
7230 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7231 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7232 int arg3 ;
7233 void *argp1 = 0 ;
7234 int res1 = 0 ;
7235 void *argp2 = 0 ;
7236 int res2 = 0 ;
7237 int val3 ;
7238 int ecode3 = 0 ;
7239 PyObject * obj0 = 0 ;
7240 PyObject * obj1 = 0 ;
7241 PyObject * obj2 = 0 ;
7242 char * kwnames[] = {
7243 (char *) "self",(char *) "attr",(char *) "col", NULL
7244 };
7245
7246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7248 if (!SWIG_IsOK(res1)) {
7249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7250 }
7251 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7253 if (!SWIG_IsOK(res2)) {
7254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7255 }
7256 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7257 ecode3 = SWIG_AsVal_int(obj2, &val3);
7258 if (!SWIG_IsOK(ecode3)) {
7259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7260 }
7261 arg3 = static_cast< int >(val3);
7262 {
7263 PyThreadState* __tstate = wxPyBeginAllowThreads();
7264 (arg1)->SetColAttr(arg2,arg3);
7265 wxPyEndAllowThreads(__tstate);
7266 if (PyErr_Occurred()) SWIG_fail;
7267 }
7268 resultobj = SWIG_Py_Void();
7269 return resultobj;
7270 fail:
7271 return NULL;
7272 }
7273
7274
7275 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7276 PyObject *resultobj = 0;
7277 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7278 size_t arg2 ;
7279 int arg3 ;
7280 void *argp1 = 0 ;
7281 int res1 = 0 ;
7282 size_t val2 ;
7283 int ecode2 = 0 ;
7284 int val3 ;
7285 int ecode3 = 0 ;
7286 PyObject * obj0 = 0 ;
7287 PyObject * obj1 = 0 ;
7288 PyObject * obj2 = 0 ;
7289 char * kwnames[] = {
7290 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7291 };
7292
7293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7295 if (!SWIG_IsOK(res1)) {
7296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7297 }
7298 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7299 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7300 if (!SWIG_IsOK(ecode2)) {
7301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7302 }
7303 arg2 = static_cast< size_t >(val2);
7304 ecode3 = SWIG_AsVal_int(obj2, &val3);
7305 if (!SWIG_IsOK(ecode3)) {
7306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7307 }
7308 arg3 = static_cast< int >(val3);
7309 {
7310 PyThreadState* __tstate = wxPyBeginAllowThreads();
7311 (arg1)->UpdateAttrRows(arg2,arg3);
7312 wxPyEndAllowThreads(__tstate);
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 resultobj = SWIG_Py_Void();
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj = 0;
7324 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7325 size_t arg2 ;
7326 int arg3 ;
7327 void *argp1 = 0 ;
7328 int res1 = 0 ;
7329 size_t val2 ;
7330 int ecode2 = 0 ;
7331 int val3 ;
7332 int ecode3 = 0 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 PyObject * obj2 = 0 ;
7336 char * kwnames[] = {
7337 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7338 };
7339
7340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7342 if (!SWIG_IsOK(res1)) {
7343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7344 }
7345 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7346 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7347 if (!SWIG_IsOK(ecode2)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7349 }
7350 arg2 = static_cast< size_t >(val2);
7351 ecode3 = SWIG_AsVal_int(obj2, &val3);
7352 if (!SWIG_IsOK(ecode3)) {
7353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7354 }
7355 arg3 = static_cast< int >(val3);
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 (arg1)->UpdateAttrCols(arg2,arg3);
7359 wxPyEndAllowThreads(__tstate);
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_Py_Void();
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7370 PyObject *obj;
7371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7372 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7373 return SWIG_Py_Void();
7374 }
7375
7376 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7377 return SWIG_Python_InitShadowInstance(args);
7378 }
7379
7380 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7381 PyObject *resultobj = 0;
7382 wxPyGridCellAttrProvider *result = 0 ;
7383
7384 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7399 PyObject *resultobj = 0;
7400 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7401 PyObject *arg2 = (PyObject *) 0 ;
7402 PyObject *arg3 = (PyObject *) 0 ;
7403 void *argp1 = 0 ;
7404 int res1 = 0 ;
7405 PyObject * obj0 = 0 ;
7406 PyObject * obj1 = 0 ;
7407 PyObject * obj2 = 0 ;
7408 char * kwnames[] = {
7409 (char *) "self",(char *) "self",(char *) "_class", NULL
7410 };
7411
7412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7416 }
7417 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7418 arg2 = obj1;
7419 arg3 = obj2;
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 (arg1)->_setCallbackInfo(arg2,arg3);
7423 wxPyEndAllowThreads(__tstate);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 resultobj = SWIG_Py_Void();
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj = 0;
7435 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7436 int arg2 ;
7437 int arg3 ;
7438 wxGridCellAttr::wxAttrKind arg4 ;
7439 wxGridCellAttr *result = 0 ;
7440 void *argp1 = 0 ;
7441 int res1 = 0 ;
7442 int val2 ;
7443 int ecode2 = 0 ;
7444 int val3 ;
7445 int ecode3 = 0 ;
7446 int val4 ;
7447 int ecode4 = 0 ;
7448 PyObject * obj0 = 0 ;
7449 PyObject * obj1 = 0 ;
7450 PyObject * obj2 = 0 ;
7451 PyObject * obj3 = 0 ;
7452 char * kwnames[] = {
7453 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7454 };
7455
7456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7458 if (!SWIG_IsOK(res1)) {
7459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7460 }
7461 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7462 ecode2 = SWIG_AsVal_int(obj1, &val2);
7463 if (!SWIG_IsOK(ecode2)) {
7464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7465 }
7466 arg2 = static_cast< int >(val2);
7467 ecode3 = SWIG_AsVal_int(obj2, &val3);
7468 if (!SWIG_IsOK(ecode3)) {
7469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7470 }
7471 arg3 = static_cast< int >(val3);
7472 ecode4 = SWIG_AsVal_int(obj3, &val4);
7473 if (!SWIG_IsOK(ecode4)) {
7474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7475 }
7476 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7477 {
7478 PyThreadState* __tstate = wxPyBeginAllowThreads();
7479 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7480 wxPyEndAllowThreads(__tstate);
7481 if (PyErr_Occurred()) SWIG_fail;
7482 }
7483 {
7484 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7485 }
7486 return resultobj;
7487 fail:
7488 return NULL;
7489 }
7490
7491
7492 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7493 PyObject *resultobj = 0;
7494 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7495 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7496 int arg3 ;
7497 int arg4 ;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 void *argp2 = 0 ;
7501 int res2 = 0 ;
7502 int val3 ;
7503 int ecode3 = 0 ;
7504 int val4 ;
7505 int ecode4 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 PyObject * obj2 = 0 ;
7509 PyObject * obj3 = 0 ;
7510 char * kwnames[] = {
7511 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7512 };
7513
7514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7518 }
7519 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7520 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7521 if (!SWIG_IsOK(res2)) {
7522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7523 }
7524 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7525 ecode3 = SWIG_AsVal_int(obj2, &val3);
7526 if (!SWIG_IsOK(ecode3)) {
7527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7528 }
7529 arg3 = static_cast< int >(val3);
7530 ecode4 = SWIG_AsVal_int(obj3, &val4);
7531 if (!SWIG_IsOK(ecode4)) {
7532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7533 }
7534 arg4 = static_cast< int >(val4);
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 (arg1)->SetAttr(arg2,arg3,arg4);
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 resultobj = SWIG_Py_Void();
7542 return resultobj;
7543 fail:
7544 return NULL;
7545 }
7546
7547
7548 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7549 PyObject *resultobj = 0;
7550 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7551 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7552 int arg3 ;
7553 void *argp1 = 0 ;
7554 int res1 = 0 ;
7555 void *argp2 = 0 ;
7556 int res2 = 0 ;
7557 int val3 ;
7558 int ecode3 = 0 ;
7559 PyObject * obj0 = 0 ;
7560 PyObject * obj1 = 0 ;
7561 PyObject * obj2 = 0 ;
7562 char * kwnames[] = {
7563 (char *) "self",(char *) "attr",(char *) "row", NULL
7564 };
7565
7566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7568 if (!SWIG_IsOK(res1)) {
7569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7570 }
7571 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7573 if (!SWIG_IsOK(res2)) {
7574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7575 }
7576 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7577 ecode3 = SWIG_AsVal_int(obj2, &val3);
7578 if (!SWIG_IsOK(ecode3)) {
7579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7580 }
7581 arg3 = static_cast< int >(val3);
7582 {
7583 PyThreadState* __tstate = wxPyBeginAllowThreads();
7584 (arg1)->SetRowAttr(arg2,arg3);
7585 wxPyEndAllowThreads(__tstate);
7586 if (PyErr_Occurred()) SWIG_fail;
7587 }
7588 resultobj = SWIG_Py_Void();
7589 return resultobj;
7590 fail:
7591 return NULL;
7592 }
7593
7594
7595 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7596 PyObject *resultobj = 0;
7597 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7598 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7599 int arg3 ;
7600 void *argp1 = 0 ;
7601 int res1 = 0 ;
7602 void *argp2 = 0 ;
7603 int res2 = 0 ;
7604 int val3 ;
7605 int ecode3 = 0 ;
7606 PyObject * obj0 = 0 ;
7607 PyObject * obj1 = 0 ;
7608 PyObject * obj2 = 0 ;
7609 char * kwnames[] = {
7610 (char *) "self",(char *) "attr",(char *) "col", NULL
7611 };
7612
7613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7615 if (!SWIG_IsOK(res1)) {
7616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7617 }
7618 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7620 if (!SWIG_IsOK(res2)) {
7621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7622 }
7623 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7624 ecode3 = SWIG_AsVal_int(obj2, &val3);
7625 if (!SWIG_IsOK(ecode3)) {
7626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7627 }
7628 arg3 = static_cast< int >(val3);
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 (arg1)->SetColAttr(arg2,arg3);
7632 wxPyEndAllowThreads(__tstate);
7633 if (PyErr_Occurred()) SWIG_fail;
7634 }
7635 resultobj = SWIG_Py_Void();
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7643 PyObject *obj;
7644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7645 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7646 return SWIG_Py_Void();
7647 }
7648
7649 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7650 return SWIG_Python_InitShadowInstance(args);
7651 }
7652
7653 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7654 PyObject *resultobj = 0;
7655 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 PyObject *swig_obj[1] ;
7659
7660 if (!args) SWIG_fail;
7661 swig_obj[0] = args;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7665 }
7666 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 delete arg1;
7670
7671 wxPyEndAllowThreads(__tstate);
7672 if (PyErr_Occurred()) SWIG_fail;
7673 }
7674 resultobj = SWIG_Py_Void();
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7682 PyObject *resultobj = 0;
7683 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7684 PyObject *arg2 = (PyObject *) 0 ;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 PyObject * obj0 = 0 ;
7688 PyObject * obj1 = 0 ;
7689 char * kwnames[] = {
7690 (char *) "self",(char *) "_self", NULL
7691 };
7692
7693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7695 if (!SWIG_IsOK(res1)) {
7696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7697 }
7698 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7699 arg2 = obj1;
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 wxGridTableBase__setOORInfo(arg1,arg2);
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 resultobj = SWIG_Py_Void();
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7714 PyObject *resultobj = 0;
7715 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7716 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7717 void *argp1 = 0 ;
7718 int res1 = 0 ;
7719 void *argp2 = 0 ;
7720 int res2 = 0 ;
7721 PyObject * obj0 = 0 ;
7722 PyObject * obj1 = 0 ;
7723 char * kwnames[] = {
7724 (char *) "self",(char *) "attrProvider", NULL
7725 };
7726
7727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7729 if (!SWIG_IsOK(res1)) {
7730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7731 }
7732 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7734 if (!SWIG_IsOK(res2)) {
7735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7736 }
7737 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7738 {
7739 PyThreadState* __tstate = wxPyBeginAllowThreads();
7740 (arg1)->SetAttrProvider(arg2);
7741 wxPyEndAllowThreads(__tstate);
7742 if (PyErr_Occurred()) SWIG_fail;
7743 }
7744 resultobj = SWIG_Py_Void();
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7752 PyObject *resultobj = 0;
7753 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7754 wxGridCellAttrProvider *result = 0 ;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 PyObject *swig_obj[1] ;
7758
7759 if (!args) SWIG_fail;
7760 swig_obj[0] = args;
7761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7764 }
7765 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7766 {
7767 PyThreadState* __tstate = wxPyBeginAllowThreads();
7768 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7769 wxPyEndAllowThreads(__tstate);
7770 if (PyErr_Occurred()) SWIG_fail;
7771 }
7772 {
7773 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7774 }
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7782 PyObject *resultobj = 0;
7783 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7784 wxGrid *arg2 = (wxGrid *) 0 ;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 void *argp2 = 0 ;
7788 int res2 = 0 ;
7789 PyObject * obj0 = 0 ;
7790 PyObject * obj1 = 0 ;
7791 char * kwnames[] = {
7792 (char *) "self",(char *) "grid", NULL
7793 };
7794
7795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7797 if (!SWIG_IsOK(res1)) {
7798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7799 }
7800 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7802 if (!SWIG_IsOK(res2)) {
7803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7804 }
7805 arg2 = reinterpret_cast< wxGrid * >(argp2);
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 (arg1)->SetView(arg2);
7809 wxPyEndAllowThreads(__tstate);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 resultobj = SWIG_Py_Void();
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7820 PyObject *resultobj = 0;
7821 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7822 wxGrid *result = 0 ;
7823 void *argp1 = 0 ;
7824 int res1 = 0 ;
7825 PyObject *swig_obj[1] ;
7826
7827 if (!args) SWIG_fail;
7828 swig_obj[0] = args;
7829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7830 if (!SWIG_IsOK(res1)) {
7831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7832 }
7833 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7837 wxPyEndAllowThreads(__tstate);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 {
7841 resultobj = wxPyMake_wxObject(result, (bool)0);
7842 }
7843 return resultobj;
7844 fail:
7845 return NULL;
7846 }
7847
7848
7849 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7850 PyObject *resultobj = 0;
7851 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7852 int result;
7853 void *argp1 = 0 ;
7854 int res1 = 0 ;
7855 PyObject *swig_obj[1] ;
7856
7857 if (!args) SWIG_fail;
7858 swig_obj[0] = args;
7859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7860 if (!SWIG_IsOK(res1)) {
7861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7862 }
7863 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7864 {
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 result = (int)(arg1)->GetNumberRows();
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = SWIG_From_int(static_cast< int >(result));
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 PyObject *resultobj = 0;
7879 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7880 int result;
7881 void *argp1 = 0 ;
7882 int res1 = 0 ;
7883 PyObject *swig_obj[1] ;
7884
7885 if (!args) SWIG_fail;
7886 swig_obj[0] = args;
7887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7890 }
7891 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7892 {
7893 PyThreadState* __tstate = wxPyBeginAllowThreads();
7894 result = (int)(arg1)->GetNumberCols();
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 resultobj = SWIG_From_int(static_cast< int >(result));
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7906 PyObject *resultobj = 0;
7907 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7908 int arg2 ;
7909 int arg3 ;
7910 bool result;
7911 void *argp1 = 0 ;
7912 int res1 = 0 ;
7913 int val2 ;
7914 int ecode2 = 0 ;
7915 int val3 ;
7916 int ecode3 = 0 ;
7917 PyObject * obj0 = 0 ;
7918 PyObject * obj1 = 0 ;
7919 PyObject * obj2 = 0 ;
7920 char * kwnames[] = {
7921 (char *) "self",(char *) "row",(char *) "col", NULL
7922 };
7923
7924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7926 if (!SWIG_IsOK(res1)) {
7927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7928 }
7929 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7930 ecode2 = SWIG_AsVal_int(obj1, &val2);
7931 if (!SWIG_IsOK(ecode2)) {
7932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7933 }
7934 arg2 = static_cast< int >(val2);
7935 ecode3 = SWIG_AsVal_int(obj2, &val3);
7936 if (!SWIG_IsOK(ecode3)) {
7937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7938 }
7939 arg3 = static_cast< int >(val3);
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 {
7947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7948 }
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7956 PyObject *resultobj = 0;
7957 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7958 int arg2 ;
7959 int arg3 ;
7960 wxString result;
7961 void *argp1 = 0 ;
7962 int res1 = 0 ;
7963 int val2 ;
7964 int ecode2 = 0 ;
7965 int val3 ;
7966 int ecode3 = 0 ;
7967 PyObject * obj0 = 0 ;
7968 PyObject * obj1 = 0 ;
7969 PyObject * obj2 = 0 ;
7970 char * kwnames[] = {
7971 (char *) "self",(char *) "row",(char *) "col", NULL
7972 };
7973
7974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7976 if (!SWIG_IsOK(res1)) {
7977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7978 }
7979 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7980 ecode2 = SWIG_AsVal_int(obj1, &val2);
7981 if (!SWIG_IsOK(ecode2)) {
7982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7983 }
7984 arg2 = static_cast< int >(val2);
7985 ecode3 = SWIG_AsVal_int(obj2, &val3);
7986 if (!SWIG_IsOK(ecode3)) {
7987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7988 }
7989 arg3 = static_cast< int >(val3);
7990 {
7991 PyThreadState* __tstate = wxPyBeginAllowThreads();
7992 result = (arg1)->GetValue(arg2,arg3);
7993 wxPyEndAllowThreads(__tstate);
7994 if (PyErr_Occurred()) SWIG_fail;
7995 }
7996 {
7997 #if wxUSE_UNICODE
7998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7999 #else
8000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8001 #endif
8002 }
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj = 0;
8011 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8012 int arg2 ;
8013 int arg3 ;
8014 wxString *arg4 = 0 ;
8015 void *argp1 = 0 ;
8016 int res1 = 0 ;
8017 int val2 ;
8018 int ecode2 = 0 ;
8019 int val3 ;
8020 int ecode3 = 0 ;
8021 bool temp4 = false ;
8022 PyObject * obj0 = 0 ;
8023 PyObject * obj1 = 0 ;
8024 PyObject * obj2 = 0 ;
8025 PyObject * obj3 = 0 ;
8026 char * kwnames[] = {
8027 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8028 };
8029
8030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8032 if (!SWIG_IsOK(res1)) {
8033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8034 }
8035 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8036 ecode2 = SWIG_AsVal_int(obj1, &val2);
8037 if (!SWIG_IsOK(ecode2)) {
8038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8039 }
8040 arg2 = static_cast< int >(val2);
8041 ecode3 = SWIG_AsVal_int(obj2, &val3);
8042 if (!SWIG_IsOK(ecode3)) {
8043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8044 }
8045 arg3 = static_cast< int >(val3);
8046 {
8047 arg4 = wxString_in_helper(obj3);
8048 if (arg4 == NULL) SWIG_fail;
8049 temp4 = true;
8050 }
8051 {
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8054 wxPyEndAllowThreads(__tstate);
8055 if (PyErr_Occurred()) SWIG_fail;
8056 }
8057 resultobj = SWIG_Py_Void();
8058 {
8059 if (temp4)
8060 delete arg4;
8061 }
8062 return resultobj;
8063 fail:
8064 {
8065 if (temp4)
8066 delete arg4;
8067 }
8068 return NULL;
8069 }
8070
8071
8072 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj = 0;
8074 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8075 int arg2 ;
8076 int arg3 ;
8077 wxString result;
8078 void *argp1 = 0 ;
8079 int res1 = 0 ;
8080 int val2 ;
8081 int ecode2 = 0 ;
8082 int val3 ;
8083 int ecode3 = 0 ;
8084 PyObject * obj0 = 0 ;
8085 PyObject * obj1 = 0 ;
8086 PyObject * obj2 = 0 ;
8087 char * kwnames[] = {
8088 (char *) "self",(char *) "row",(char *) "col", NULL
8089 };
8090
8091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8093 if (!SWIG_IsOK(res1)) {
8094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8095 }
8096 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8097 ecode2 = SWIG_AsVal_int(obj1, &val2);
8098 if (!SWIG_IsOK(ecode2)) {
8099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8100 }
8101 arg2 = static_cast< int >(val2);
8102 ecode3 = SWIG_AsVal_int(obj2, &val3);
8103 if (!SWIG_IsOK(ecode3)) {
8104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8105 }
8106 arg3 = static_cast< int >(val3);
8107 {
8108 PyThreadState* __tstate = wxPyBeginAllowThreads();
8109 result = (arg1)->GetTypeName(arg2,arg3);
8110 wxPyEndAllowThreads(__tstate);
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 {
8114 #if wxUSE_UNICODE
8115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8116 #else
8117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8118 #endif
8119 }
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj = 0;
8128 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8129 int arg2 ;
8130 int arg3 ;
8131 wxString *arg4 = 0 ;
8132 bool result;
8133 void *argp1 = 0 ;
8134 int res1 = 0 ;
8135 int val2 ;
8136 int ecode2 = 0 ;
8137 int val3 ;
8138 int ecode3 = 0 ;
8139 bool temp4 = false ;
8140 PyObject * obj0 = 0 ;
8141 PyObject * obj1 = 0 ;
8142 PyObject * obj2 = 0 ;
8143 PyObject * obj3 = 0 ;
8144 char * kwnames[] = {
8145 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8146 };
8147
8148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8150 if (!SWIG_IsOK(res1)) {
8151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8152 }
8153 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8154 ecode2 = SWIG_AsVal_int(obj1, &val2);
8155 if (!SWIG_IsOK(ecode2)) {
8156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8157 }
8158 arg2 = static_cast< int >(val2);
8159 ecode3 = SWIG_AsVal_int(obj2, &val3);
8160 if (!SWIG_IsOK(ecode3)) {
8161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8162 }
8163 arg3 = static_cast< int >(val3);
8164 {
8165 arg4 = wxString_in_helper(obj3);
8166 if (arg4 == NULL) SWIG_fail;
8167 temp4 = true;
8168 }
8169 {
8170 PyThreadState* __tstate = wxPyBeginAllowThreads();
8171 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8172 wxPyEndAllowThreads(__tstate);
8173 if (PyErr_Occurred()) SWIG_fail;
8174 }
8175 {
8176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8177 }
8178 {
8179 if (temp4)
8180 delete arg4;
8181 }
8182 return resultobj;
8183 fail:
8184 {
8185 if (temp4)
8186 delete arg4;
8187 }
8188 return NULL;
8189 }
8190
8191
8192 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8193 PyObject *resultobj = 0;
8194 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8195 int arg2 ;
8196 int arg3 ;
8197 wxString *arg4 = 0 ;
8198 bool result;
8199 void *argp1 = 0 ;
8200 int res1 = 0 ;
8201 int val2 ;
8202 int ecode2 = 0 ;
8203 int val3 ;
8204 int ecode3 = 0 ;
8205 bool temp4 = false ;
8206 PyObject * obj0 = 0 ;
8207 PyObject * obj1 = 0 ;
8208 PyObject * obj2 = 0 ;
8209 PyObject * obj3 = 0 ;
8210 char * kwnames[] = {
8211 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8212 };
8213
8214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8216 if (!SWIG_IsOK(res1)) {
8217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8218 }
8219 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8220 ecode2 = SWIG_AsVal_int(obj1, &val2);
8221 if (!SWIG_IsOK(ecode2)) {
8222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8223 }
8224 arg2 = static_cast< int >(val2);
8225 ecode3 = SWIG_AsVal_int(obj2, &val3);
8226 if (!SWIG_IsOK(ecode3)) {
8227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8228 }
8229 arg3 = static_cast< int >(val3);
8230 {
8231 arg4 = wxString_in_helper(obj3);
8232 if (arg4 == NULL) SWIG_fail;
8233 temp4 = true;
8234 }
8235 {
8236 PyThreadState* __tstate = wxPyBeginAllowThreads();
8237 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 {
8242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8243 }
8244 {
8245 if (temp4)
8246 delete arg4;
8247 }
8248 return resultobj;
8249 fail:
8250 {
8251 if (temp4)
8252 delete arg4;
8253 }
8254 return NULL;
8255 }
8256
8257
8258 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj = 0;
8260 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8261 int arg2 ;
8262 int arg3 ;
8263 long result;
8264 void *argp1 = 0 ;
8265 int res1 = 0 ;
8266 int val2 ;
8267 int ecode2 = 0 ;
8268 int val3 ;
8269 int ecode3 = 0 ;
8270 PyObject * obj0 = 0 ;
8271 PyObject * obj1 = 0 ;
8272 PyObject * obj2 = 0 ;
8273 char * kwnames[] = {
8274 (char *) "self",(char *) "row",(char *) "col", NULL
8275 };
8276
8277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8279 if (!SWIG_IsOK(res1)) {
8280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8281 }
8282 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8283 ecode2 = SWIG_AsVal_int(obj1, &val2);
8284 if (!SWIG_IsOK(ecode2)) {
8285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8286 }
8287 arg2 = static_cast< int >(val2);
8288 ecode3 = SWIG_AsVal_int(obj2, &val3);
8289 if (!SWIG_IsOK(ecode3)) {
8290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8291 }
8292 arg3 = static_cast< int >(val3);
8293 {
8294 PyThreadState* __tstate = wxPyBeginAllowThreads();
8295 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8296 wxPyEndAllowThreads(__tstate);
8297 if (PyErr_Occurred()) SWIG_fail;
8298 }
8299 resultobj = SWIG_From_long(static_cast< long >(result));
8300 return resultobj;
8301 fail:
8302 return NULL;
8303 }
8304
8305
8306 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8307 PyObject *resultobj = 0;
8308 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8309 int arg2 ;
8310 int arg3 ;
8311 double result;
8312 void *argp1 = 0 ;
8313 int res1 = 0 ;
8314 int val2 ;
8315 int ecode2 = 0 ;
8316 int val3 ;
8317 int ecode3 = 0 ;
8318 PyObject * obj0 = 0 ;
8319 PyObject * obj1 = 0 ;
8320 PyObject * obj2 = 0 ;
8321 char * kwnames[] = {
8322 (char *) "self",(char *) "row",(char *) "col", NULL
8323 };
8324
8325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8327 if (!SWIG_IsOK(res1)) {
8328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8329 }
8330 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8331 ecode2 = SWIG_AsVal_int(obj1, &val2);
8332 if (!SWIG_IsOK(ecode2)) {
8333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8334 }
8335 arg2 = static_cast< int >(val2);
8336 ecode3 = SWIG_AsVal_int(obj2, &val3);
8337 if (!SWIG_IsOK(ecode3)) {
8338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8339 }
8340 arg3 = static_cast< int >(val3);
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8344 wxPyEndAllowThreads(__tstate);
8345 if (PyErr_Occurred()) SWIG_fail;
8346 }
8347 resultobj = SWIG_From_double(static_cast< double >(result));
8348 return resultobj;
8349 fail:
8350 return NULL;
8351 }
8352
8353
8354 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8355 PyObject *resultobj = 0;
8356 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8357 int arg2 ;
8358 int arg3 ;
8359 bool result;
8360 void *argp1 = 0 ;
8361 int res1 = 0 ;
8362 int val2 ;
8363 int ecode2 = 0 ;
8364 int val3 ;
8365 int ecode3 = 0 ;
8366 PyObject * obj0 = 0 ;
8367 PyObject * obj1 = 0 ;
8368 PyObject * obj2 = 0 ;
8369 char * kwnames[] = {
8370 (char *) "self",(char *) "row",(char *) "col", NULL
8371 };
8372
8373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8375 if (!SWIG_IsOK(res1)) {
8376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8377 }
8378 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8379 ecode2 = SWIG_AsVal_int(obj1, &val2);
8380 if (!SWIG_IsOK(ecode2)) {
8381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8382 }
8383 arg2 = static_cast< int >(val2);
8384 ecode3 = SWIG_AsVal_int(obj2, &val3);
8385 if (!SWIG_IsOK(ecode3)) {
8386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8387 }
8388 arg3 = static_cast< int >(val3);
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8392 wxPyEndAllowThreads(__tstate);
8393 if (PyErr_Occurred()) SWIG_fail;
8394 }
8395 {
8396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8397 }
8398 return resultobj;
8399 fail:
8400 return NULL;
8401 }
8402
8403
8404 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8405 PyObject *resultobj = 0;
8406 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8407 int arg2 ;
8408 int arg3 ;
8409 long arg4 ;
8410 void *argp1 = 0 ;
8411 int res1 = 0 ;
8412 int val2 ;
8413 int ecode2 = 0 ;
8414 int val3 ;
8415 int ecode3 = 0 ;
8416 long val4 ;
8417 int ecode4 = 0 ;
8418 PyObject * obj0 = 0 ;
8419 PyObject * obj1 = 0 ;
8420 PyObject * obj2 = 0 ;
8421 PyObject * obj3 = 0 ;
8422 char * kwnames[] = {
8423 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8424 };
8425
8426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8428 if (!SWIG_IsOK(res1)) {
8429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8430 }
8431 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8432 ecode2 = SWIG_AsVal_int(obj1, &val2);
8433 if (!SWIG_IsOK(ecode2)) {
8434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8435 }
8436 arg2 = static_cast< int >(val2);
8437 ecode3 = SWIG_AsVal_int(obj2, &val3);
8438 if (!SWIG_IsOK(ecode3)) {
8439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8440 }
8441 arg3 = static_cast< int >(val3);
8442 ecode4 = SWIG_AsVal_long(obj3, &val4);
8443 if (!SWIG_IsOK(ecode4)) {
8444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8445 }
8446 arg4 = static_cast< long >(val4);
8447 {
8448 PyThreadState* __tstate = wxPyBeginAllowThreads();
8449 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 resultobj = SWIG_Py_Void();
8454 return resultobj;
8455 fail:
8456 return NULL;
8457 }
8458
8459
8460 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8461 PyObject *resultobj = 0;
8462 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8463 int arg2 ;
8464 int arg3 ;
8465 double arg4 ;
8466 void *argp1 = 0 ;
8467 int res1 = 0 ;
8468 int val2 ;
8469 int ecode2 = 0 ;
8470 int val3 ;
8471 int ecode3 = 0 ;
8472 double val4 ;
8473 int ecode4 = 0 ;
8474 PyObject * obj0 = 0 ;
8475 PyObject * obj1 = 0 ;
8476 PyObject * obj2 = 0 ;
8477 PyObject * obj3 = 0 ;
8478 char * kwnames[] = {
8479 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8480 };
8481
8482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8484 if (!SWIG_IsOK(res1)) {
8485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8486 }
8487 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8488 ecode2 = SWIG_AsVal_int(obj1, &val2);
8489 if (!SWIG_IsOK(ecode2)) {
8490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8491 }
8492 arg2 = static_cast< int >(val2);
8493 ecode3 = SWIG_AsVal_int(obj2, &val3);
8494 if (!SWIG_IsOK(ecode3)) {
8495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8496 }
8497 arg3 = static_cast< int >(val3);
8498 ecode4 = SWIG_AsVal_double(obj3, &val4);
8499 if (!SWIG_IsOK(ecode4)) {
8500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8501 }
8502 arg4 = static_cast< double >(val4);
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 resultobj = SWIG_Py_Void();
8510 return resultobj;
8511 fail:
8512 return NULL;
8513 }
8514
8515
8516 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8517 PyObject *resultobj = 0;
8518 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8519 int arg2 ;
8520 int arg3 ;
8521 bool arg4 ;
8522 void *argp1 = 0 ;
8523 int res1 = 0 ;
8524 int val2 ;
8525 int ecode2 = 0 ;
8526 int val3 ;
8527 int ecode3 = 0 ;
8528 bool val4 ;
8529 int ecode4 = 0 ;
8530 PyObject * obj0 = 0 ;
8531 PyObject * obj1 = 0 ;
8532 PyObject * obj2 = 0 ;
8533 PyObject * obj3 = 0 ;
8534 char * kwnames[] = {
8535 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8536 };
8537
8538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8540 if (!SWIG_IsOK(res1)) {
8541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8542 }
8543 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8544 ecode2 = SWIG_AsVal_int(obj1, &val2);
8545 if (!SWIG_IsOK(ecode2)) {
8546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8547 }
8548 arg2 = static_cast< int >(val2);
8549 ecode3 = SWIG_AsVal_int(obj2, &val3);
8550 if (!SWIG_IsOK(ecode3)) {
8551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8552 }
8553 arg3 = static_cast< int >(val3);
8554 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8555 if (!SWIG_IsOK(ecode4)) {
8556 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8557 }
8558 arg4 = static_cast< bool >(val4);
8559 {
8560 PyThreadState* __tstate = wxPyBeginAllowThreads();
8561 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 resultobj = SWIG_Py_Void();
8566 return resultobj;
8567 fail:
8568 return NULL;
8569 }
8570
8571
8572 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8573 PyObject *resultobj = 0;
8574 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8575 void *argp1 = 0 ;
8576 int res1 = 0 ;
8577 PyObject *swig_obj[1] ;
8578
8579 if (!args) SWIG_fail;
8580 swig_obj[0] = args;
8581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8582 if (!SWIG_IsOK(res1)) {
8583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8584 }
8585 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8586 {
8587 PyThreadState* __tstate = wxPyBeginAllowThreads();
8588 (arg1)->Clear();
8589 wxPyEndAllowThreads(__tstate);
8590 if (PyErr_Occurred()) SWIG_fail;
8591 }
8592 resultobj = SWIG_Py_Void();
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj = 0;
8601 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8602 size_t arg2 = (size_t) 0 ;
8603 size_t arg3 = (size_t) 1 ;
8604 bool result;
8605 void *argp1 = 0 ;
8606 int res1 = 0 ;
8607 size_t val2 ;
8608 int ecode2 = 0 ;
8609 size_t val3 ;
8610 int ecode3 = 0 ;
8611 PyObject * obj0 = 0 ;
8612 PyObject * obj1 = 0 ;
8613 PyObject * obj2 = 0 ;
8614 char * kwnames[] = {
8615 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8616 };
8617
8618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8620 if (!SWIG_IsOK(res1)) {
8621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8622 }
8623 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8624 if (obj1) {
8625 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8626 if (!SWIG_IsOK(ecode2)) {
8627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8628 }
8629 arg2 = static_cast< size_t >(val2);
8630 }
8631 if (obj2) {
8632 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8633 if (!SWIG_IsOK(ecode3)) {
8634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8635 }
8636 arg3 = static_cast< size_t >(val3);
8637 }
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 result = (bool)(arg1)->InsertRows(arg2,arg3);
8641 wxPyEndAllowThreads(__tstate);
8642 if (PyErr_Occurred()) SWIG_fail;
8643 }
8644 {
8645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8646 }
8647 return resultobj;
8648 fail:
8649 return NULL;
8650 }
8651
8652
8653 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj = 0;
8655 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8656 size_t arg2 = (size_t) 1 ;
8657 bool result;
8658 void *argp1 = 0 ;
8659 int res1 = 0 ;
8660 size_t val2 ;
8661 int ecode2 = 0 ;
8662 PyObject * obj0 = 0 ;
8663 PyObject * obj1 = 0 ;
8664 char * kwnames[] = {
8665 (char *) "self",(char *) "numRows", NULL
8666 };
8667
8668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8670 if (!SWIG_IsOK(res1)) {
8671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8672 }
8673 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8674 if (obj1) {
8675 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8676 if (!SWIG_IsOK(ecode2)) {
8677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8678 }
8679 arg2 = static_cast< size_t >(val2);
8680 }
8681 {
8682 PyThreadState* __tstate = wxPyBeginAllowThreads();
8683 result = (bool)(arg1)->AppendRows(arg2);
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 {
8688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8689 }
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8697 PyObject *resultobj = 0;
8698 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8699 size_t arg2 = (size_t) 0 ;
8700 size_t arg3 = (size_t) 1 ;
8701 bool result;
8702 void *argp1 = 0 ;
8703 int res1 = 0 ;
8704 size_t val2 ;
8705 int ecode2 = 0 ;
8706 size_t val3 ;
8707 int ecode3 = 0 ;
8708 PyObject * obj0 = 0 ;
8709 PyObject * obj1 = 0 ;
8710 PyObject * obj2 = 0 ;
8711 char * kwnames[] = {
8712 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8713 };
8714
8715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8717 if (!SWIG_IsOK(res1)) {
8718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8719 }
8720 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8721 if (obj1) {
8722 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8723 if (!SWIG_IsOK(ecode2)) {
8724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8725 }
8726 arg2 = static_cast< size_t >(val2);
8727 }
8728 if (obj2) {
8729 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8730 if (!SWIG_IsOK(ecode3)) {
8731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8732 }
8733 arg3 = static_cast< size_t >(val3);
8734 }
8735 {
8736 PyThreadState* __tstate = wxPyBeginAllowThreads();
8737 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8738 wxPyEndAllowThreads(__tstate);
8739 if (PyErr_Occurred()) SWIG_fail;
8740 }
8741 {
8742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8743 }
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj = 0;
8752 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8753 size_t arg2 = (size_t) 0 ;
8754 size_t arg3 = (size_t) 1 ;
8755 bool result;
8756 void *argp1 = 0 ;
8757 int res1 = 0 ;
8758 size_t val2 ;
8759 int ecode2 = 0 ;
8760 size_t val3 ;
8761 int ecode3 = 0 ;
8762 PyObject * obj0 = 0 ;
8763 PyObject * obj1 = 0 ;
8764 PyObject * obj2 = 0 ;
8765 char * kwnames[] = {
8766 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8767 };
8768
8769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8771 if (!SWIG_IsOK(res1)) {
8772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8773 }
8774 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8775 if (obj1) {
8776 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8777 if (!SWIG_IsOK(ecode2)) {
8778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8779 }
8780 arg2 = static_cast< size_t >(val2);
8781 }
8782 if (obj2) {
8783 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8784 if (!SWIG_IsOK(ecode3)) {
8785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8786 }
8787 arg3 = static_cast< size_t >(val3);
8788 }
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 result = (bool)(arg1)->InsertCols(arg2,arg3);
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 {
8796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8797 }
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj = 0;
8806 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8807 size_t arg2 = (size_t) 1 ;
8808 bool result;
8809 void *argp1 = 0 ;
8810 int res1 = 0 ;
8811 size_t val2 ;
8812 int ecode2 = 0 ;
8813 PyObject * obj0 = 0 ;
8814 PyObject * obj1 = 0 ;
8815 char * kwnames[] = {
8816 (char *) "self",(char *) "numCols", NULL
8817 };
8818
8819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8821 if (!SWIG_IsOK(res1)) {
8822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8823 }
8824 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8825 if (obj1) {
8826 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8827 if (!SWIG_IsOK(ecode2)) {
8828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8829 }
8830 arg2 = static_cast< size_t >(val2);
8831 }
8832 {
8833 PyThreadState* __tstate = wxPyBeginAllowThreads();
8834 result = (bool)(arg1)->AppendCols(arg2);
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 {
8839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8840 }
8841 return resultobj;
8842 fail:
8843 return NULL;
8844 }
8845
8846
8847 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8848 PyObject *resultobj = 0;
8849 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8850 size_t arg2 = (size_t) 0 ;
8851 size_t arg3 = (size_t) 1 ;
8852 bool result;
8853 void *argp1 = 0 ;
8854 int res1 = 0 ;
8855 size_t val2 ;
8856 int ecode2 = 0 ;
8857 size_t val3 ;
8858 int ecode3 = 0 ;
8859 PyObject * obj0 = 0 ;
8860 PyObject * obj1 = 0 ;
8861 PyObject * obj2 = 0 ;
8862 char * kwnames[] = {
8863 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8864 };
8865
8866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8868 if (!SWIG_IsOK(res1)) {
8869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8870 }
8871 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8872 if (obj1) {
8873 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8874 if (!SWIG_IsOK(ecode2)) {
8875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8876 }
8877 arg2 = static_cast< size_t >(val2);
8878 }
8879 if (obj2) {
8880 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8881 if (!SWIG_IsOK(ecode3)) {
8882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8883 }
8884 arg3 = static_cast< size_t >(val3);
8885 }
8886 {
8887 PyThreadState* __tstate = wxPyBeginAllowThreads();
8888 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8889 wxPyEndAllowThreads(__tstate);
8890 if (PyErr_Occurred()) SWIG_fail;
8891 }
8892 {
8893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8894 }
8895 return resultobj;
8896 fail:
8897 return NULL;
8898 }
8899
8900
8901 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8902 PyObject *resultobj = 0;
8903 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8904 int arg2 ;
8905 wxString result;
8906 void *argp1 = 0 ;
8907 int res1 = 0 ;
8908 int val2 ;
8909 int ecode2 = 0 ;
8910 PyObject * obj0 = 0 ;
8911 PyObject * obj1 = 0 ;
8912 char * kwnames[] = {
8913 (char *) "self",(char *) "row", NULL
8914 };
8915
8916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8918 if (!SWIG_IsOK(res1)) {
8919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8920 }
8921 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8922 ecode2 = SWIG_AsVal_int(obj1, &val2);
8923 if (!SWIG_IsOK(ecode2)) {
8924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8925 }
8926 arg2 = static_cast< int >(val2);
8927 {
8928 PyThreadState* __tstate = wxPyBeginAllowThreads();
8929 result = (arg1)->GetRowLabelValue(arg2);
8930 wxPyEndAllowThreads(__tstate);
8931 if (PyErr_Occurred()) SWIG_fail;
8932 }
8933 {
8934 #if wxUSE_UNICODE
8935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8936 #else
8937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8938 #endif
8939 }
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8947 PyObject *resultobj = 0;
8948 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8949 int arg2 ;
8950 wxString result;
8951 void *argp1 = 0 ;
8952 int res1 = 0 ;
8953 int val2 ;
8954 int ecode2 = 0 ;
8955 PyObject * obj0 = 0 ;
8956 PyObject * obj1 = 0 ;
8957 char * kwnames[] = {
8958 (char *) "self",(char *) "col", NULL
8959 };
8960
8961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8963 if (!SWIG_IsOK(res1)) {
8964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8965 }
8966 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8967 ecode2 = SWIG_AsVal_int(obj1, &val2);
8968 if (!SWIG_IsOK(ecode2)) {
8969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8970 }
8971 arg2 = static_cast< int >(val2);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (arg1)->GetColLabelValue(arg2);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 {
8979 #if wxUSE_UNICODE
8980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8981 #else
8982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8983 #endif
8984 }
8985 return resultobj;
8986 fail:
8987 return NULL;
8988 }
8989
8990
8991 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8992 PyObject *resultobj = 0;
8993 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8994 int arg2 ;
8995 wxString *arg3 = 0 ;
8996 void *argp1 = 0 ;
8997 int res1 = 0 ;
8998 int val2 ;
8999 int ecode2 = 0 ;
9000 bool temp3 = false ;
9001 PyObject * obj0 = 0 ;
9002 PyObject * obj1 = 0 ;
9003 PyObject * obj2 = 0 ;
9004 char * kwnames[] = {
9005 (char *) "self",(char *) "row",(char *) "value", NULL
9006 };
9007
9008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9010 if (!SWIG_IsOK(res1)) {
9011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9012 }
9013 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9014 ecode2 = SWIG_AsVal_int(obj1, &val2);
9015 if (!SWIG_IsOK(ecode2)) {
9016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9017 }
9018 arg2 = static_cast< int >(val2);
9019 {
9020 arg3 = wxString_in_helper(obj2);
9021 if (arg3 == NULL) SWIG_fail;
9022 temp3 = true;
9023 }
9024 {
9025 PyThreadState* __tstate = wxPyBeginAllowThreads();
9026 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9027 wxPyEndAllowThreads(__tstate);
9028 if (PyErr_Occurred()) SWIG_fail;
9029 }
9030 resultobj = SWIG_Py_Void();
9031 {
9032 if (temp3)
9033 delete arg3;
9034 }
9035 return resultobj;
9036 fail:
9037 {
9038 if (temp3)
9039 delete arg3;
9040 }
9041 return NULL;
9042 }
9043
9044
9045 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj = 0;
9047 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9048 int arg2 ;
9049 wxString *arg3 = 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 int val2 ;
9053 int ecode2 = 0 ;
9054 bool temp3 = false ;
9055 PyObject * obj0 = 0 ;
9056 PyObject * obj1 = 0 ;
9057 PyObject * obj2 = 0 ;
9058 char * kwnames[] = {
9059 (char *) "self",(char *) "col",(char *) "value", NULL
9060 };
9061
9062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9064 if (!SWIG_IsOK(res1)) {
9065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9066 }
9067 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9068 ecode2 = SWIG_AsVal_int(obj1, &val2);
9069 if (!SWIG_IsOK(ecode2)) {
9070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9071 }
9072 arg2 = static_cast< int >(val2);
9073 {
9074 arg3 = wxString_in_helper(obj2);
9075 if (arg3 == NULL) SWIG_fail;
9076 temp3 = true;
9077 }
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9081 wxPyEndAllowThreads(__tstate);
9082 if (PyErr_Occurred()) SWIG_fail;
9083 }
9084 resultobj = SWIG_Py_Void();
9085 {
9086 if (temp3)
9087 delete arg3;
9088 }
9089 return resultobj;
9090 fail:
9091 {
9092 if (temp3)
9093 delete arg3;
9094 }
9095 return NULL;
9096 }
9097
9098
9099 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9100 PyObject *resultobj = 0;
9101 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9102 bool result;
9103 void *argp1 = 0 ;
9104 int res1 = 0 ;
9105 PyObject *swig_obj[1] ;
9106
9107 if (!args) SWIG_fail;
9108 swig_obj[0] = args;
9109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9110 if (!SWIG_IsOK(res1)) {
9111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9112 }
9113 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 result = (bool)(arg1)->CanHaveAttributes();
9117 wxPyEndAllowThreads(__tstate);
9118 if (PyErr_Occurred()) SWIG_fail;
9119 }
9120 {
9121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9122 }
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9130 PyObject *resultobj = 0;
9131 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9132 int arg2 ;
9133 int arg3 ;
9134 wxGridCellAttr::wxAttrKind arg4 ;
9135 wxGridCellAttr *result = 0 ;
9136 void *argp1 = 0 ;
9137 int res1 = 0 ;
9138 int val2 ;
9139 int ecode2 = 0 ;
9140 int val3 ;
9141 int ecode3 = 0 ;
9142 int val4 ;
9143 int ecode4 = 0 ;
9144 PyObject * obj0 = 0 ;
9145 PyObject * obj1 = 0 ;
9146 PyObject * obj2 = 0 ;
9147 PyObject * obj3 = 0 ;
9148 char * kwnames[] = {
9149 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9150 };
9151
9152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9154 if (!SWIG_IsOK(res1)) {
9155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9156 }
9157 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9158 ecode2 = SWIG_AsVal_int(obj1, &val2);
9159 if (!SWIG_IsOK(ecode2)) {
9160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9161 }
9162 arg2 = static_cast< int >(val2);
9163 ecode3 = SWIG_AsVal_int(obj2, &val3);
9164 if (!SWIG_IsOK(ecode3)) {
9165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9166 }
9167 arg3 = static_cast< int >(val3);
9168 ecode4 = SWIG_AsVal_int(obj3, &val4);
9169 if (!SWIG_IsOK(ecode4)) {
9170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9171 }
9172 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 {
9180 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9181 }
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9189 PyObject *resultobj = 0;
9190 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9191 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9192 int arg3 ;
9193 int arg4 ;
9194 void *argp1 = 0 ;
9195 int res1 = 0 ;
9196 void *argp2 = 0 ;
9197 int res2 = 0 ;
9198 int val3 ;
9199 int ecode3 = 0 ;
9200 int val4 ;
9201 int ecode4 = 0 ;
9202 PyObject * obj0 = 0 ;
9203 PyObject * obj1 = 0 ;
9204 PyObject * obj2 = 0 ;
9205 PyObject * obj3 = 0 ;
9206 char * kwnames[] = {
9207 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9208 };
9209
9210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9212 if (!SWIG_IsOK(res1)) {
9213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9214 }
9215 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9217 if (!SWIG_IsOK(res2)) {
9218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9219 }
9220 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9221 ecode3 = SWIG_AsVal_int(obj2, &val3);
9222 if (!SWIG_IsOK(ecode3)) {
9223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9224 }
9225 arg3 = static_cast< int >(val3);
9226 ecode4 = SWIG_AsVal_int(obj3, &val4);
9227 if (!SWIG_IsOK(ecode4)) {
9228 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9229 }
9230 arg4 = static_cast< int >(val4);
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 (arg1)->SetAttr(arg2,arg3,arg4);
9234 wxPyEndAllowThreads(__tstate);
9235 if (PyErr_Occurred()) SWIG_fail;
9236 }
9237 resultobj = SWIG_Py_Void();
9238 return resultobj;
9239 fail:
9240 return NULL;
9241 }
9242
9243
9244 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9245 PyObject *resultobj = 0;
9246 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9247 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9248 int arg3 ;
9249 void *argp1 = 0 ;
9250 int res1 = 0 ;
9251 void *argp2 = 0 ;
9252 int res2 = 0 ;
9253 int val3 ;
9254 int ecode3 = 0 ;
9255 PyObject * obj0 = 0 ;
9256 PyObject * obj1 = 0 ;
9257 PyObject * obj2 = 0 ;
9258 char * kwnames[] = {
9259 (char *) "self",(char *) "attr",(char *) "row", NULL
9260 };
9261
9262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9266 }
9267 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9269 if (!SWIG_IsOK(res2)) {
9270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9271 }
9272 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9273 ecode3 = SWIG_AsVal_int(obj2, &val3);
9274 if (!SWIG_IsOK(ecode3)) {
9275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9276 }
9277 arg3 = static_cast< int >(val3);
9278 {
9279 PyThreadState* __tstate = wxPyBeginAllowThreads();
9280 (arg1)->SetRowAttr(arg2,arg3);
9281 wxPyEndAllowThreads(__tstate);
9282 if (PyErr_Occurred()) SWIG_fail;
9283 }
9284 resultobj = SWIG_Py_Void();
9285 return resultobj;
9286 fail:
9287 return NULL;
9288 }
9289
9290
9291 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9292 PyObject *resultobj = 0;
9293 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9294 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9295 int arg3 ;
9296 void *argp1 = 0 ;
9297 int res1 = 0 ;
9298 void *argp2 = 0 ;
9299 int res2 = 0 ;
9300 int val3 ;
9301 int ecode3 = 0 ;
9302 PyObject * obj0 = 0 ;
9303 PyObject * obj1 = 0 ;
9304 PyObject * obj2 = 0 ;
9305 char * kwnames[] = {
9306 (char *) "self",(char *) "attr",(char *) "col", NULL
9307 };
9308
9309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9311 if (!SWIG_IsOK(res1)) {
9312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9313 }
9314 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9315 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9316 if (!SWIG_IsOK(res2)) {
9317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9318 }
9319 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9320 ecode3 = SWIG_AsVal_int(obj2, &val3);
9321 if (!SWIG_IsOK(ecode3)) {
9322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9323 }
9324 arg3 = static_cast< int >(val3);
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 (arg1)->SetColAttr(arg2,arg3);
9328 wxPyEndAllowThreads(__tstate);
9329 if (PyErr_Occurred()) SWIG_fail;
9330 }
9331 resultobj = SWIG_Py_Void();
9332 return resultobj;
9333 fail:
9334 return NULL;
9335 }
9336
9337
9338 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9339 PyObject *obj;
9340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9341 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9342 return SWIG_Py_Void();
9343 }
9344
9345 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9346 PyObject *resultobj = 0;
9347 wxPyGridTableBase *result = 0 ;
9348
9349 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9350 {
9351 PyThreadState* __tstate = wxPyBeginAllowThreads();
9352 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9353 wxPyEndAllowThreads(__tstate);
9354 if (PyErr_Occurred()) SWIG_fail;
9355 }
9356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9357 return resultobj;
9358 fail:
9359 return NULL;
9360 }
9361
9362
9363 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9364 PyObject *resultobj = 0;
9365 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9366 PyObject *arg2 = (PyObject *) 0 ;
9367 PyObject *arg3 = (PyObject *) 0 ;
9368 void *argp1 = 0 ;
9369 int res1 = 0 ;
9370 PyObject * obj0 = 0 ;
9371 PyObject * obj1 = 0 ;
9372 PyObject * obj2 = 0 ;
9373 char * kwnames[] = {
9374 (char *) "self",(char *) "self",(char *) "_class", NULL
9375 };
9376
9377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9379 if (!SWIG_IsOK(res1)) {
9380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9381 }
9382 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9383 arg2 = obj1;
9384 arg3 = obj2;
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 (arg1)->_setCallbackInfo(arg2,arg3);
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 resultobj = SWIG_Py_Void();
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9399 PyObject *resultobj = 0;
9400 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 PyObject *swig_obj[1] ;
9404
9405 if (!args) SWIG_fail;
9406 swig_obj[0] = args;
9407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9408 if (!SWIG_IsOK(res1)) {
9409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9410 }
9411 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 wxPyGridTableBase_Destroy(arg1);
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_Py_Void();
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9426 PyObject *obj;
9427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9428 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9429 return SWIG_Py_Void();
9430 }
9431
9432 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9433 return SWIG_Python_InitShadowInstance(args);
9434 }
9435
9436 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9437 PyObject *resultobj = 0;
9438 int arg1 = (int) 0 ;
9439 int arg2 = (int) 0 ;
9440 wxGridStringTable *result = 0 ;
9441 int val1 ;
9442 int ecode1 = 0 ;
9443 int val2 ;
9444 int ecode2 = 0 ;
9445 PyObject * obj0 = 0 ;
9446 PyObject * obj1 = 0 ;
9447 char * kwnames[] = {
9448 (char *) "numRows",(char *) "numCols", NULL
9449 };
9450
9451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9452 if (obj0) {
9453 ecode1 = SWIG_AsVal_int(obj0, &val1);
9454 if (!SWIG_IsOK(ecode1)) {
9455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9456 }
9457 arg1 = static_cast< int >(val1);
9458 }
9459 if (obj1) {
9460 ecode2 = SWIG_AsVal_int(obj1, &val2);
9461 if (!SWIG_IsOK(ecode2)) {
9462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9463 }
9464 arg2 = static_cast< int >(val2);
9465 }
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9469 wxPyEndAllowThreads(__tstate);
9470 if (PyErr_Occurred()) SWIG_fail;
9471 }
9472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9473 return resultobj;
9474 fail:
9475 return NULL;
9476 }
9477
9478
9479 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9480 PyObject *obj;
9481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9482 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9483 return SWIG_Py_Void();
9484 }
9485
9486 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9487 return SWIG_Python_InitShadowInstance(args);
9488 }
9489
9490 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9491 PyObject *resultobj = 0;
9492 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9493 int arg2 ;
9494 int arg3 = (int) -1 ;
9495 int arg4 = (int) -1 ;
9496 wxGridTableMessage *result = 0 ;
9497 void *argp1 = 0 ;
9498 int res1 = 0 ;
9499 int val2 ;
9500 int ecode2 = 0 ;
9501 int val3 ;
9502 int ecode3 = 0 ;
9503 int val4 ;
9504 int ecode4 = 0 ;
9505 PyObject * obj0 = 0 ;
9506 PyObject * obj1 = 0 ;
9507 PyObject * obj2 = 0 ;
9508 PyObject * obj3 = 0 ;
9509 char * kwnames[] = {
9510 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9511 };
9512
9513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9515 if (!SWIG_IsOK(res1)) {
9516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9517 }
9518 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9519 ecode2 = SWIG_AsVal_int(obj1, &val2);
9520 if (!SWIG_IsOK(ecode2)) {
9521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9522 }
9523 arg2 = static_cast< int >(val2);
9524 if (obj2) {
9525 ecode3 = SWIG_AsVal_int(obj2, &val3);
9526 if (!SWIG_IsOK(ecode3)) {
9527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9528 }
9529 arg3 = static_cast< int >(val3);
9530 }
9531 if (obj3) {
9532 ecode4 = SWIG_AsVal_int(obj3, &val4);
9533 if (!SWIG_IsOK(ecode4)) {
9534 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9535 }
9536 arg4 = static_cast< int >(val4);
9537 }
9538 {
9539 PyThreadState* __tstate = wxPyBeginAllowThreads();
9540 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9545 return resultobj;
9546 fail:
9547 return NULL;
9548 }
9549
9550
9551 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9552 PyObject *resultobj = 0;
9553 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9554 void *argp1 = 0 ;
9555 int res1 = 0 ;
9556 PyObject *swig_obj[1] ;
9557
9558 if (!args) SWIG_fail;
9559 swig_obj[0] = args;
9560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9561 if (!SWIG_IsOK(res1)) {
9562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9563 }
9564 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9565 {
9566 PyThreadState* __tstate = wxPyBeginAllowThreads();
9567 delete arg1;
9568
9569 wxPyEndAllowThreads(__tstate);
9570 if (PyErr_Occurred()) SWIG_fail;
9571 }
9572 resultobj = SWIG_Py_Void();
9573 return resultobj;
9574 fail:
9575 return NULL;
9576 }
9577
9578
9579 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9580 PyObject *resultobj = 0;
9581 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9582 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9583 void *argp1 = 0 ;
9584 int res1 = 0 ;
9585 void *argp2 = 0 ;
9586 int res2 = 0 ;
9587 PyObject * obj0 = 0 ;
9588 PyObject * obj1 = 0 ;
9589 char * kwnames[] = {
9590 (char *) "self",(char *) "table", NULL
9591 };
9592
9593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9595 if (!SWIG_IsOK(res1)) {
9596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9597 }
9598 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9600 if (!SWIG_IsOK(res2)) {
9601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9602 }
9603 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9604 {
9605 PyThreadState* __tstate = wxPyBeginAllowThreads();
9606 (arg1)->SetTableObject(arg2);
9607 wxPyEndAllowThreads(__tstate);
9608 if (PyErr_Occurred()) SWIG_fail;
9609 }
9610 resultobj = SWIG_Py_Void();
9611 return resultobj;
9612 fail:
9613 return NULL;
9614 }
9615
9616
9617 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9618 PyObject *resultobj = 0;
9619 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9620 wxGridTableBase *result = 0 ;
9621 void *argp1 = 0 ;
9622 int res1 = 0 ;
9623 PyObject *swig_obj[1] ;
9624
9625 if (!args) SWIG_fail;
9626 swig_obj[0] = args;
9627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9628 if (!SWIG_IsOK(res1)) {
9629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9630 }
9631 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9635 wxPyEndAllowThreads(__tstate);
9636 if (PyErr_Occurred()) SWIG_fail;
9637 }
9638 {
9639 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9640 }
9641 return resultobj;
9642 fail:
9643 return NULL;
9644 }
9645
9646
9647 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9648 PyObject *resultobj = 0;
9649 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9650 int arg2 ;
9651 void *argp1 = 0 ;
9652 int res1 = 0 ;
9653 int val2 ;
9654 int ecode2 = 0 ;
9655 PyObject * obj0 = 0 ;
9656 PyObject * obj1 = 0 ;
9657 char * kwnames[] = {
9658 (char *) "self",(char *) "id", NULL
9659 };
9660
9661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9663 if (!SWIG_IsOK(res1)) {
9664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9665 }
9666 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9667 ecode2 = SWIG_AsVal_int(obj1, &val2);
9668 if (!SWIG_IsOK(ecode2)) {
9669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9670 }
9671 arg2 = static_cast< int >(val2);
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 (arg1)->SetId(arg2);
9675 wxPyEndAllowThreads(__tstate);
9676 if (PyErr_Occurred()) SWIG_fail;
9677 }
9678 resultobj = SWIG_Py_Void();
9679 return resultobj;
9680 fail:
9681 return NULL;
9682 }
9683
9684
9685 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9686 PyObject *resultobj = 0;
9687 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9688 int result;
9689 void *argp1 = 0 ;
9690 int res1 = 0 ;
9691 PyObject *swig_obj[1] ;
9692
9693 if (!args) SWIG_fail;
9694 swig_obj[0] = args;
9695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9696 if (!SWIG_IsOK(res1)) {
9697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9698 }
9699 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9700 {
9701 PyThreadState* __tstate = wxPyBeginAllowThreads();
9702 result = (int)(arg1)->GetId();
9703 wxPyEndAllowThreads(__tstate);
9704 if (PyErr_Occurred()) SWIG_fail;
9705 }
9706 resultobj = SWIG_From_int(static_cast< int >(result));
9707 return resultobj;
9708 fail:
9709 return NULL;
9710 }
9711
9712
9713 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9714 PyObject *resultobj = 0;
9715 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9716 int arg2 ;
9717 void *argp1 = 0 ;
9718 int res1 = 0 ;
9719 int val2 ;
9720 int ecode2 = 0 ;
9721 PyObject * obj0 = 0 ;
9722 PyObject * obj1 = 0 ;
9723 char * kwnames[] = {
9724 (char *) "self",(char *) "comInt1", NULL
9725 };
9726
9727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9729 if (!SWIG_IsOK(res1)) {
9730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9731 }
9732 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9733 ecode2 = SWIG_AsVal_int(obj1, &val2);
9734 if (!SWIG_IsOK(ecode2)) {
9735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9736 }
9737 arg2 = static_cast< int >(val2);
9738 {
9739 PyThreadState* __tstate = wxPyBeginAllowThreads();
9740 (arg1)->SetCommandInt(arg2);
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 resultobj = SWIG_Py_Void();
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752 PyObject *resultobj = 0;
9753 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9754 int result;
9755 void *argp1 = 0 ;
9756 int res1 = 0 ;
9757 PyObject *swig_obj[1] ;
9758
9759 if (!args) SWIG_fail;
9760 swig_obj[0] = args;
9761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9762 if (!SWIG_IsOK(res1)) {
9763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9764 }
9765 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 result = (int)(arg1)->GetCommandInt();
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 resultobj = SWIG_From_int(static_cast< int >(result));
9773 return resultobj;
9774 fail:
9775 return NULL;
9776 }
9777
9778
9779 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9780 PyObject *resultobj = 0;
9781 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9782 int arg2 ;
9783 void *argp1 = 0 ;
9784 int res1 = 0 ;
9785 int val2 ;
9786 int ecode2 = 0 ;
9787 PyObject * obj0 = 0 ;
9788 PyObject * obj1 = 0 ;
9789 char * kwnames[] = {
9790 (char *) "self",(char *) "comInt2", NULL
9791 };
9792
9793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9795 if (!SWIG_IsOK(res1)) {
9796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9797 }
9798 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9799 ecode2 = SWIG_AsVal_int(obj1, &val2);
9800 if (!SWIG_IsOK(ecode2)) {
9801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9802 }
9803 arg2 = static_cast< int >(val2);
9804 {
9805 PyThreadState* __tstate = wxPyBeginAllowThreads();
9806 (arg1)->SetCommandInt2(arg2);
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 resultobj = SWIG_Py_Void();
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818 PyObject *resultobj = 0;
9819 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9820 int result;
9821 void *argp1 = 0 ;
9822 int res1 = 0 ;
9823 PyObject *swig_obj[1] ;
9824
9825 if (!args) SWIG_fail;
9826 swig_obj[0] = args;
9827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9828 if (!SWIG_IsOK(res1)) {
9829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9830 }
9831 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9832 {
9833 PyThreadState* __tstate = wxPyBeginAllowThreads();
9834 result = (int)(arg1)->GetCommandInt2();
9835 wxPyEndAllowThreads(__tstate);
9836 if (PyErr_Occurred()) SWIG_fail;
9837 }
9838 resultobj = SWIG_From_int(static_cast< int >(result));
9839 return resultobj;
9840 fail:
9841 return NULL;
9842 }
9843
9844
9845 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9846 PyObject *obj;
9847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9848 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9849 return SWIG_Py_Void();
9850 }
9851
9852 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9853 return SWIG_Python_InitShadowInstance(args);
9854 }
9855
9856 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj = 0;
9858 int arg1 = (int) -1 ;
9859 int arg2 = (int) -1 ;
9860 wxGridCellCoords *result = 0 ;
9861 int val1 ;
9862 int ecode1 = 0 ;
9863 int val2 ;
9864 int ecode2 = 0 ;
9865 PyObject * obj0 = 0 ;
9866 PyObject * obj1 = 0 ;
9867 char * kwnames[] = {
9868 (char *) "r",(char *) "c", NULL
9869 };
9870
9871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9872 if (obj0) {
9873 ecode1 = SWIG_AsVal_int(obj0, &val1);
9874 if (!SWIG_IsOK(ecode1)) {
9875 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9876 }
9877 arg1 = static_cast< int >(val1);
9878 }
9879 if (obj1) {
9880 ecode2 = SWIG_AsVal_int(obj1, &val2);
9881 if (!SWIG_IsOK(ecode2)) {
9882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9883 }
9884 arg2 = static_cast< int >(val2);
9885 }
9886 {
9887 PyThreadState* __tstate = wxPyBeginAllowThreads();
9888 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9889 wxPyEndAllowThreads(__tstate);
9890 if (PyErr_Occurred()) SWIG_fail;
9891 }
9892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9893 return resultobj;
9894 fail:
9895 return NULL;
9896 }
9897
9898
9899 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9900 PyObject *resultobj = 0;
9901 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9902 void *argp1 = 0 ;
9903 int res1 = 0 ;
9904 PyObject *swig_obj[1] ;
9905
9906 if (!args) SWIG_fail;
9907 swig_obj[0] = args;
9908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9909 if (!SWIG_IsOK(res1)) {
9910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9911 }
9912 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 delete arg1;
9916
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 resultobj = SWIG_Py_Void();
9921 return resultobj;
9922 fail:
9923 return NULL;
9924 }
9925
9926
9927 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9928 PyObject *resultobj = 0;
9929 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9930 int result;
9931 void *argp1 = 0 ;
9932 int res1 = 0 ;
9933 PyObject *swig_obj[1] ;
9934
9935 if (!args) SWIG_fail;
9936 swig_obj[0] = args;
9937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9938 if (!SWIG_IsOK(res1)) {
9939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9940 }
9941 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9942 {
9943 PyThreadState* __tstate = wxPyBeginAllowThreads();
9944 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 resultobj = SWIG_From_int(static_cast< int >(result));
9949 return resultobj;
9950 fail:
9951 return NULL;
9952 }
9953
9954
9955 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9956 PyObject *resultobj = 0;
9957 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9958 int arg2 ;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 int val2 ;
9962 int ecode2 = 0 ;
9963 PyObject * obj0 = 0 ;
9964 PyObject * obj1 = 0 ;
9965 char * kwnames[] = {
9966 (char *) "self",(char *) "n", NULL
9967 };
9968
9969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
9970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9971 if (!SWIG_IsOK(res1)) {
9972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9973 }
9974 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9975 ecode2 = SWIG_AsVal_int(obj1, &val2);
9976 if (!SWIG_IsOK(ecode2)) {
9977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
9978 }
9979 arg2 = static_cast< int >(val2);
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 (arg1)->SetRow(arg2);
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_Py_Void();
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9994 PyObject *resultobj = 0;
9995 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9996 int result;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 PyObject *swig_obj[1] ;
10000
10001 if (!args) SWIG_fail;
10002 swig_obj[0] = args;
10003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10004 if (!SWIG_IsOK(res1)) {
10005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10006 }
10007 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10008 {
10009 PyThreadState* __tstate = wxPyBeginAllowThreads();
10010 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10011 wxPyEndAllowThreads(__tstate);
10012 if (PyErr_Occurred()) SWIG_fail;
10013 }
10014 resultobj = SWIG_From_int(static_cast< int >(result));
10015 return resultobj;
10016 fail:
10017 return NULL;
10018 }
10019
10020
10021 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj = 0;
10023 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10024 int arg2 ;
10025 void *argp1 = 0 ;
10026 int res1 = 0 ;
10027 int val2 ;
10028 int ecode2 = 0 ;
10029 PyObject * obj0 = 0 ;
10030 PyObject * obj1 = 0 ;
10031 char * kwnames[] = {
10032 (char *) "self",(char *) "n", NULL
10033 };
10034
10035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10037 if (!SWIG_IsOK(res1)) {
10038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10039 }
10040 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10041 ecode2 = SWIG_AsVal_int(obj1, &val2);
10042 if (!SWIG_IsOK(ecode2)) {
10043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10044 }
10045 arg2 = static_cast< int >(val2);
10046 {
10047 PyThreadState* __tstate = wxPyBeginAllowThreads();
10048 (arg1)->SetCol(arg2);
10049 wxPyEndAllowThreads(__tstate);
10050 if (PyErr_Occurred()) SWIG_fail;
10051 }
10052 resultobj = SWIG_Py_Void();
10053 return resultobj;
10054 fail:
10055 return NULL;
10056 }
10057
10058
10059 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10060 PyObject *resultobj = 0;
10061 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10062 int arg2 ;
10063 int arg3 ;
10064 void *argp1 = 0 ;
10065 int res1 = 0 ;
10066 int val2 ;
10067 int ecode2 = 0 ;
10068 int val3 ;
10069 int ecode3 = 0 ;
10070 PyObject * obj0 = 0 ;
10071 PyObject * obj1 = 0 ;
10072 PyObject * obj2 = 0 ;
10073 char * kwnames[] = {
10074 (char *) "self",(char *) "row",(char *) "col", NULL
10075 };
10076
10077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10079 if (!SWIG_IsOK(res1)) {
10080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10081 }
10082 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10083 ecode2 = SWIG_AsVal_int(obj1, &val2);
10084 if (!SWIG_IsOK(ecode2)) {
10085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10086 }
10087 arg2 = static_cast< int >(val2);
10088 ecode3 = SWIG_AsVal_int(obj2, &val3);
10089 if (!SWIG_IsOK(ecode3)) {
10090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10091 }
10092 arg3 = static_cast< int >(val3);
10093 {
10094 PyThreadState* __tstate = wxPyBeginAllowThreads();
10095 (arg1)->Set(arg2,arg3);
10096 wxPyEndAllowThreads(__tstate);
10097 if (PyErr_Occurred()) SWIG_fail;
10098 }
10099 resultobj = SWIG_Py_Void();
10100 return resultobj;
10101 fail:
10102 return NULL;
10103 }
10104
10105
10106 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10107 PyObject *resultobj = 0;
10108 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10109 PyObject *arg2 = (PyObject *) 0 ;
10110 bool result;
10111 void *argp1 = 0 ;
10112 int res1 = 0 ;
10113 PyObject * obj0 = 0 ;
10114 PyObject * obj1 = 0 ;
10115 char * kwnames[] = {
10116 (char *) "self",(char *) "other", NULL
10117 };
10118
10119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10121 if (!SWIG_IsOK(res1)) {
10122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10123 }
10124 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10125 arg2 = obj1;
10126 {
10127 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10128 if (PyErr_Occurred()) SWIG_fail;
10129 }
10130 {
10131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10132 }
10133 return resultobj;
10134 fail:
10135 return NULL;
10136 }
10137
10138
10139 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10140 PyObject *resultobj = 0;
10141 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10142 PyObject *arg2 = (PyObject *) 0 ;
10143 bool result;
10144 void *argp1 = 0 ;
10145 int res1 = 0 ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 char * kwnames[] = {
10149 (char *) "self",(char *) "other", NULL
10150 };
10151
10152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10154 if (!SWIG_IsOK(res1)) {
10155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10156 }
10157 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10158 arg2 = obj1;
10159 {
10160 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10161 if (PyErr_Occurred()) SWIG_fail;
10162 }
10163 {
10164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10165 }
10166 return resultobj;
10167 fail:
10168 return NULL;
10169 }
10170
10171
10172 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10173 PyObject *resultobj = 0;
10174 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10175 PyObject *result = 0 ;
10176 void *argp1 = 0 ;
10177 int res1 = 0 ;
10178 PyObject *swig_obj[1] ;
10179
10180 if (!args) SWIG_fail;
10181 swig_obj[0] = args;
10182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10183 if (!SWIG_IsOK(res1)) {
10184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10185 }
10186 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (PyObject *)wxGridCellCoords_Get(arg1);
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 resultobj = result;
10194 return resultobj;
10195 fail:
10196 return NULL;
10197 }
10198
10199
10200 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10201 PyObject *obj;
10202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10203 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10204 return SWIG_Py_Void();
10205 }
10206
10207 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10208 return SWIG_Python_InitShadowInstance(args);
10209 }
10210
10211 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj = 0;
10213 wxWindow *arg1 = (wxWindow *) 0 ;
10214 int arg2 = (int) -1 ;
10215 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10216 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10217 wxSize const &arg4_defvalue = wxDefaultSize ;
10218 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10219 long arg5 = (long) wxWANTS_CHARS ;
10220 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10221 wxString *arg6 = (wxString *) &arg6_defvalue ;
10222 wxGrid *result = 0 ;
10223 void *argp1 = 0 ;
10224 int res1 = 0 ;
10225 int val2 ;
10226 int ecode2 = 0 ;
10227 wxPoint temp3 ;
10228 wxSize temp4 ;
10229 long val5 ;
10230 int ecode5 = 0 ;
10231 bool temp6 = false ;
10232 PyObject * obj0 = 0 ;
10233 PyObject * obj1 = 0 ;
10234 PyObject * obj2 = 0 ;
10235 PyObject * obj3 = 0 ;
10236 PyObject * obj4 = 0 ;
10237 PyObject * obj5 = 0 ;
10238 char * kwnames[] = {
10239 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10240 };
10241
10242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10244 if (!SWIG_IsOK(res1)) {
10245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10246 }
10247 arg1 = reinterpret_cast< wxWindow * >(argp1);
10248 if (obj1) {
10249 ecode2 = SWIG_AsVal_int(obj1, &val2);
10250 if (!SWIG_IsOK(ecode2)) {
10251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10252 }
10253 arg2 = static_cast< int >(val2);
10254 }
10255 if (obj2) {
10256 {
10257 arg3 = &temp3;
10258 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10259 }
10260 }
10261 if (obj3) {
10262 {
10263 arg4 = &temp4;
10264 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10265 }
10266 }
10267 if (obj4) {
10268 ecode5 = SWIG_AsVal_long(obj4, &val5);
10269 if (!SWIG_IsOK(ecode5)) {
10270 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10271 }
10272 arg5 = static_cast< long >(val5);
10273 }
10274 if (obj5) {
10275 {
10276 arg6 = wxString_in_helper(obj5);
10277 if (arg6 == NULL) SWIG_fail;
10278 temp6 = true;
10279 }
10280 }
10281 {
10282 if (!wxPyCheckForApp()) SWIG_fail;
10283 PyThreadState* __tstate = wxPyBeginAllowThreads();
10284 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10285 wxPyEndAllowThreads(__tstate);
10286 if (PyErr_Occurred()) SWIG_fail;
10287 }
10288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10289 {
10290 if (temp6)
10291 delete arg6;
10292 }
10293 return resultobj;
10294 fail:
10295 {
10296 if (temp6)
10297 delete arg6;
10298 }
10299 return NULL;
10300 }
10301
10302
10303 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10304 PyObject *resultobj = 0;
10305 wxGrid *result = 0 ;
10306
10307 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10308 {
10309 if (!wxPyCheckForApp()) SWIG_fail;
10310 PyThreadState* __tstate = wxPyBeginAllowThreads();
10311 result = (wxGrid *)new wxGrid();
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10323 PyObject *resultobj = 0;
10324 wxGrid *arg1 = (wxGrid *) 0 ;
10325 wxWindow *arg2 = (wxWindow *) 0 ;
10326 int arg3 = (int) -1 ;
10327 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10328 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10329 wxSize const &arg5_defvalue = wxDefaultSize ;
10330 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10331 long arg6 = (long) wxWANTS_CHARS ;
10332 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10333 wxString *arg7 = (wxString *) &arg7_defvalue ;
10334 bool result;
10335 void *argp1 = 0 ;
10336 int res1 = 0 ;
10337 void *argp2 = 0 ;
10338 int res2 = 0 ;
10339 int val3 ;
10340 int ecode3 = 0 ;
10341 wxPoint temp4 ;
10342 wxSize temp5 ;
10343 long val6 ;
10344 int ecode6 = 0 ;
10345 bool temp7 = false ;
10346 PyObject * obj0 = 0 ;
10347 PyObject * obj1 = 0 ;
10348 PyObject * obj2 = 0 ;
10349 PyObject * obj3 = 0 ;
10350 PyObject * obj4 = 0 ;
10351 PyObject * obj5 = 0 ;
10352 PyObject * obj6 = 0 ;
10353 char * kwnames[] = {
10354 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10355 };
10356
10357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10359 if (!SWIG_IsOK(res1)) {
10360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10361 }
10362 arg1 = reinterpret_cast< wxGrid * >(argp1);
10363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10364 if (!SWIG_IsOK(res2)) {
10365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10366 }
10367 arg2 = reinterpret_cast< wxWindow * >(argp2);
10368 if (obj2) {
10369 ecode3 = SWIG_AsVal_int(obj2, &val3);
10370 if (!SWIG_IsOK(ecode3)) {
10371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10372 }
10373 arg3 = static_cast< int >(val3);
10374 }
10375 if (obj3) {
10376 {
10377 arg4 = &temp4;
10378 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10379 }
10380 }
10381 if (obj4) {
10382 {
10383 arg5 = &temp5;
10384 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10385 }
10386 }
10387 if (obj5) {
10388 ecode6 = SWIG_AsVal_long(obj5, &val6);
10389 if (!SWIG_IsOK(ecode6)) {
10390 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10391 }
10392 arg6 = static_cast< long >(val6);
10393 }
10394 if (obj6) {
10395 {
10396 arg7 = wxString_in_helper(obj6);
10397 if (arg7 == NULL) SWIG_fail;
10398 temp7 = true;
10399 }
10400 }
10401 {
10402 PyThreadState* __tstate = wxPyBeginAllowThreads();
10403 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10404 wxPyEndAllowThreads(__tstate);
10405 if (PyErr_Occurred()) SWIG_fail;
10406 }
10407 {
10408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10409 }
10410 {
10411 if (temp7)
10412 delete arg7;
10413 }
10414 return resultobj;
10415 fail:
10416 {
10417 if (temp7)
10418 delete arg7;
10419 }
10420 return NULL;
10421 }
10422
10423
10424 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10425 PyObject *resultobj = 0;
10426 wxGrid *arg1 = (wxGrid *) 0 ;
10427 int arg2 ;
10428 int arg3 ;
10429 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10430 bool result;
10431 void *argp1 = 0 ;
10432 int res1 = 0 ;
10433 int val2 ;
10434 int ecode2 = 0 ;
10435 int val3 ;
10436 int ecode3 = 0 ;
10437 int val4 ;
10438 int ecode4 = 0 ;
10439 PyObject * obj0 = 0 ;
10440 PyObject * obj1 = 0 ;
10441 PyObject * obj2 = 0 ;
10442 PyObject * obj3 = 0 ;
10443 char * kwnames[] = {
10444 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10445 };
10446
10447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10449 if (!SWIG_IsOK(res1)) {
10450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10451 }
10452 arg1 = reinterpret_cast< wxGrid * >(argp1);
10453 ecode2 = SWIG_AsVal_int(obj1, &val2);
10454 if (!SWIG_IsOK(ecode2)) {
10455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10456 }
10457 arg2 = static_cast< int >(val2);
10458 ecode3 = SWIG_AsVal_int(obj2, &val3);
10459 if (!SWIG_IsOK(ecode3)) {
10460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10461 }
10462 arg3 = static_cast< int >(val3);
10463 if (obj3) {
10464 ecode4 = SWIG_AsVal_int(obj3, &val4);
10465 if (!SWIG_IsOK(ecode4)) {
10466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10467 }
10468 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10469 }
10470 {
10471 PyThreadState* __tstate = wxPyBeginAllowThreads();
10472 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10473 wxPyEndAllowThreads(__tstate);
10474 if (PyErr_Occurred()) SWIG_fail;
10475 }
10476 {
10477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10478 }
10479 return resultobj;
10480 fail:
10481 return NULL;
10482 }
10483
10484
10485 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10486 PyObject *resultobj = 0;
10487 wxGrid *arg1 = (wxGrid *) 0 ;
10488 WXGRIDSELECTIONMODES arg2 ;
10489 void *argp1 = 0 ;
10490 int res1 = 0 ;
10491 int val2 ;
10492 int ecode2 = 0 ;
10493 PyObject * obj0 = 0 ;
10494 PyObject * obj1 = 0 ;
10495 char * kwnames[] = {
10496 (char *) "self",(char *) "selmode", NULL
10497 };
10498
10499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10501 if (!SWIG_IsOK(res1)) {
10502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10503 }
10504 arg1 = reinterpret_cast< wxGrid * >(argp1);
10505 ecode2 = SWIG_AsVal_int(obj1, &val2);
10506 if (!SWIG_IsOK(ecode2)) {
10507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10508 }
10509 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 (arg1)->SetSelectionMode(arg2);
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 resultobj = SWIG_Py_Void();
10517 return resultobj;
10518 fail:
10519 return NULL;
10520 }
10521
10522
10523 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10524 PyObject *resultobj = 0;
10525 wxGrid *arg1 = (wxGrid *) 0 ;
10526 WXGRIDSELECTIONMODES result;
10527 void *argp1 = 0 ;
10528 int res1 = 0 ;
10529 PyObject *swig_obj[1] ;
10530
10531 if (!args) SWIG_fail;
10532 swig_obj[0] = args;
10533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10534 if (!SWIG_IsOK(res1)) {
10535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10536 }
10537 arg1 = reinterpret_cast< wxGrid * >(argp1);
10538 {
10539 PyThreadState* __tstate = wxPyBeginAllowThreads();
10540 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 resultobj = SWIG_From_int(static_cast< int >(result));
10545 return resultobj;
10546 fail:
10547 return NULL;
10548 }
10549
10550
10551 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10552 PyObject *resultobj = 0;
10553 wxGrid *arg1 = (wxGrid *) 0 ;
10554 int result;
10555 void *argp1 = 0 ;
10556 int res1 = 0 ;
10557 PyObject *swig_obj[1] ;
10558
10559 if (!args) SWIG_fail;
10560 swig_obj[0] = args;
10561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10562 if (!SWIG_IsOK(res1)) {
10563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10564 }
10565 arg1 = reinterpret_cast< wxGrid * >(argp1);
10566 {
10567 PyThreadState* __tstate = wxPyBeginAllowThreads();
10568 result = (int)(arg1)->GetNumberRows();
10569 wxPyEndAllowThreads(__tstate);
10570 if (PyErr_Occurred()) SWIG_fail;
10571 }
10572 resultobj = SWIG_From_int(static_cast< int >(result));
10573 return resultobj;
10574 fail:
10575 return NULL;
10576 }
10577
10578
10579 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10580 PyObject *resultobj = 0;
10581 wxGrid *arg1 = (wxGrid *) 0 ;
10582 int result;
10583 void *argp1 = 0 ;
10584 int res1 = 0 ;
10585 PyObject *swig_obj[1] ;
10586
10587 if (!args) SWIG_fail;
10588 swig_obj[0] = args;
10589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10590 if (!SWIG_IsOK(res1)) {
10591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10592 }
10593 arg1 = reinterpret_cast< wxGrid * >(argp1);
10594 {
10595 PyThreadState* __tstate = wxPyBeginAllowThreads();
10596 result = (int)(arg1)->GetNumberCols();
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 resultobj = SWIG_From_int(static_cast< int >(result));
10601 return resultobj;
10602 fail:
10603 return NULL;
10604 }
10605
10606
10607 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10608 PyObject *resultobj = 0;
10609 wxGrid *arg1 = (wxGrid *) 0 ;
10610 wxGridTableMessage *arg2 = 0 ;
10611 bool result;
10612 void *argp1 = 0 ;
10613 int res1 = 0 ;
10614 void *argp2 = 0 ;
10615 int res2 = 0 ;
10616 PyObject * obj0 = 0 ;
10617 PyObject * obj1 = 0 ;
10618 char * kwnames[] = {
10619 (char *) "self",(char *)"arg2", NULL
10620 };
10621
10622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10624 if (!SWIG_IsOK(res1)) {
10625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10626 }
10627 arg1 = reinterpret_cast< wxGrid * >(argp1);
10628 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10629 if (!SWIG_IsOK(res2)) {
10630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10631 }
10632 if (!argp2) {
10633 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10634 }
10635 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10636 {
10637 PyThreadState* __tstate = wxPyBeginAllowThreads();
10638 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10639 wxPyEndAllowThreads(__tstate);
10640 if (PyErr_Occurred()) SWIG_fail;
10641 }
10642 {
10643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10644 }
10645 return resultobj;
10646 fail:
10647 return NULL;
10648 }
10649
10650
10651 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10652 PyObject *resultobj = 0;
10653 wxGrid *arg1 = (wxGrid *) 0 ;
10654 wxGridTableBase *result = 0 ;
10655 void *argp1 = 0 ;
10656 int res1 = 0 ;
10657 PyObject *swig_obj[1] ;
10658
10659 if (!args) SWIG_fail;
10660 swig_obj[0] = args;
10661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10662 if (!SWIG_IsOK(res1)) {
10663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10664 }
10665 arg1 = reinterpret_cast< wxGrid * >(argp1);
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 {
10673 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10674 }
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj = 0;
10683 wxGrid *arg1 = (wxGrid *) 0 ;
10684 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10685 bool arg3 = (bool) false ;
10686 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10687 bool result;
10688 void *argp1 = 0 ;
10689 int res1 = 0 ;
10690 int res2 = 0 ;
10691 bool val3 ;
10692 int ecode3 = 0 ;
10693 int val4 ;
10694 int ecode4 = 0 ;
10695 PyObject * obj0 = 0 ;
10696 PyObject * obj1 = 0 ;
10697 PyObject * obj2 = 0 ;
10698 PyObject * obj3 = 0 ;
10699 char * kwnames[] = {
10700 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10701 };
10702
10703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10705 if (!SWIG_IsOK(res1)) {
10706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10707 }
10708 arg1 = reinterpret_cast< wxGrid * >(argp1);
10709 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10710 if (!SWIG_IsOK(res2)) {
10711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10712 }
10713 if (obj2) {
10714 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10715 if (!SWIG_IsOK(ecode3)) {
10716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10717 }
10718 arg3 = static_cast< bool >(val3);
10719 }
10720 if (obj3) {
10721 ecode4 = SWIG_AsVal_int(obj3, &val4);
10722 if (!SWIG_IsOK(ecode4)) {
10723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10724 }
10725 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10726 }
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 {
10734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10735 }
10736 return resultobj;
10737 fail:
10738 return NULL;
10739 }
10740
10741
10742 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10743 PyObject *resultobj = 0;
10744 wxGrid *arg1 = (wxGrid *) 0 ;
10745 void *argp1 = 0 ;
10746 int res1 = 0 ;
10747 PyObject *swig_obj[1] ;
10748
10749 if (!args) SWIG_fail;
10750 swig_obj[0] = args;
10751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10752 if (!SWIG_IsOK(res1)) {
10753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10754 }
10755 arg1 = reinterpret_cast< wxGrid * >(argp1);
10756 {
10757 PyThreadState* __tstate = wxPyBeginAllowThreads();
10758 (arg1)->ClearGrid();
10759 wxPyEndAllowThreads(__tstate);
10760 if (PyErr_Occurred()) SWIG_fail;
10761 }
10762 resultobj = SWIG_Py_Void();
10763 return resultobj;
10764 fail:
10765 return NULL;
10766 }
10767
10768
10769 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj = 0;
10771 wxGrid *arg1 = (wxGrid *) 0 ;
10772 int arg2 = (int) 0 ;
10773 int arg3 = (int) 1 ;
10774 bool arg4 = (bool) true ;
10775 bool result;
10776 void *argp1 = 0 ;
10777 int res1 = 0 ;
10778 int val2 ;
10779 int ecode2 = 0 ;
10780 int val3 ;
10781 int ecode3 = 0 ;
10782 bool val4 ;
10783 int ecode4 = 0 ;
10784 PyObject * obj0 = 0 ;
10785 PyObject * obj1 = 0 ;
10786 PyObject * obj2 = 0 ;
10787 PyObject * obj3 = 0 ;
10788 char * kwnames[] = {
10789 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10790 };
10791
10792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10794 if (!SWIG_IsOK(res1)) {
10795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10796 }
10797 arg1 = reinterpret_cast< wxGrid * >(argp1);
10798 if (obj1) {
10799 ecode2 = SWIG_AsVal_int(obj1, &val2);
10800 if (!SWIG_IsOK(ecode2)) {
10801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10802 }
10803 arg2 = static_cast< int >(val2);
10804 }
10805 if (obj2) {
10806 ecode3 = SWIG_AsVal_int(obj2, &val3);
10807 if (!SWIG_IsOK(ecode3)) {
10808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10809 }
10810 arg3 = static_cast< int >(val3);
10811 }
10812 if (obj3) {
10813 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10814 if (!SWIG_IsOK(ecode4)) {
10815 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10816 }
10817 arg4 = static_cast< bool >(val4);
10818 }
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10822 wxPyEndAllowThreads(__tstate);
10823 if (PyErr_Occurred()) SWIG_fail;
10824 }
10825 {
10826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10827 }
10828 return resultobj;
10829 fail:
10830 return NULL;
10831 }
10832
10833
10834 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj = 0;
10836 wxGrid *arg1 = (wxGrid *) 0 ;
10837 int arg2 = (int) 1 ;
10838 bool arg3 = (bool) true ;
10839 bool result;
10840 void *argp1 = 0 ;
10841 int res1 = 0 ;
10842 int val2 ;
10843 int ecode2 = 0 ;
10844 bool val3 ;
10845 int ecode3 = 0 ;
10846 PyObject * obj0 = 0 ;
10847 PyObject * obj1 = 0 ;
10848 PyObject * obj2 = 0 ;
10849 char * kwnames[] = {
10850 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10851 };
10852
10853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10855 if (!SWIG_IsOK(res1)) {
10856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10857 }
10858 arg1 = reinterpret_cast< wxGrid * >(argp1);
10859 if (obj1) {
10860 ecode2 = SWIG_AsVal_int(obj1, &val2);
10861 if (!SWIG_IsOK(ecode2)) {
10862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10863 }
10864 arg2 = static_cast< int >(val2);
10865 }
10866 if (obj2) {
10867 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10868 if (!SWIG_IsOK(ecode3)) {
10869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10870 }
10871 arg3 = static_cast< bool >(val3);
10872 }
10873 {
10874 PyThreadState* __tstate = wxPyBeginAllowThreads();
10875 result = (bool)(arg1)->AppendRows(arg2,arg3);
10876 wxPyEndAllowThreads(__tstate);
10877 if (PyErr_Occurred()) SWIG_fail;
10878 }
10879 {
10880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10881 }
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj = 0;
10890 wxGrid *arg1 = (wxGrid *) 0 ;
10891 int arg2 = (int) 0 ;
10892 int arg3 = (int) 1 ;
10893 bool arg4 = (bool) true ;
10894 bool result;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 int val2 ;
10898 int ecode2 = 0 ;
10899 int val3 ;
10900 int ecode3 = 0 ;
10901 bool val4 ;
10902 int ecode4 = 0 ;
10903 PyObject * obj0 = 0 ;
10904 PyObject * obj1 = 0 ;
10905 PyObject * obj2 = 0 ;
10906 PyObject * obj3 = 0 ;
10907 char * kwnames[] = {
10908 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10909 };
10910
10911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10913 if (!SWIG_IsOK(res1)) {
10914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10915 }
10916 arg1 = reinterpret_cast< wxGrid * >(argp1);
10917 if (obj1) {
10918 ecode2 = SWIG_AsVal_int(obj1, &val2);
10919 if (!SWIG_IsOK(ecode2)) {
10920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10921 }
10922 arg2 = static_cast< int >(val2);
10923 }
10924 if (obj2) {
10925 ecode3 = SWIG_AsVal_int(obj2, &val3);
10926 if (!SWIG_IsOK(ecode3)) {
10927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10928 }
10929 arg3 = static_cast< int >(val3);
10930 }
10931 if (obj3) {
10932 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10933 if (!SWIG_IsOK(ecode4)) {
10934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10935 }
10936 arg4 = static_cast< bool >(val4);
10937 }
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10941 wxPyEndAllowThreads(__tstate);
10942 if (PyErr_Occurred()) SWIG_fail;
10943 }
10944 {
10945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10946 }
10947 return resultobj;
10948 fail:
10949 return NULL;
10950 }
10951
10952
10953 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10954 PyObject *resultobj = 0;
10955 wxGrid *arg1 = (wxGrid *) 0 ;
10956 int arg2 = (int) 0 ;
10957 int arg3 = (int) 1 ;
10958 bool arg4 = (bool) true ;
10959 bool result;
10960 void *argp1 = 0 ;
10961 int res1 = 0 ;
10962 int val2 ;
10963 int ecode2 = 0 ;
10964 int val3 ;
10965 int ecode3 = 0 ;
10966 bool val4 ;
10967 int ecode4 = 0 ;
10968 PyObject * obj0 = 0 ;
10969 PyObject * obj1 = 0 ;
10970 PyObject * obj2 = 0 ;
10971 PyObject * obj3 = 0 ;
10972 char * kwnames[] = {
10973 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10974 };
10975
10976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10980 }
10981 arg1 = reinterpret_cast< wxGrid * >(argp1);
10982 if (obj1) {
10983 ecode2 = SWIG_AsVal_int(obj1, &val2);
10984 if (!SWIG_IsOK(ecode2)) {
10985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10986 }
10987 arg2 = static_cast< int >(val2);
10988 }
10989 if (obj2) {
10990 ecode3 = SWIG_AsVal_int(obj2, &val3);
10991 if (!SWIG_IsOK(ecode3)) {
10992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10993 }
10994 arg3 = static_cast< int >(val3);
10995 }
10996 if (obj3) {
10997 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10998 if (!SWIG_IsOK(ecode4)) {
10999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11000 }
11001 arg4 = static_cast< bool >(val4);
11002 }
11003 {
11004 PyThreadState* __tstate = wxPyBeginAllowThreads();
11005 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11011 }
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11019 PyObject *resultobj = 0;
11020 wxGrid *arg1 = (wxGrid *) 0 ;
11021 int arg2 = (int) 1 ;
11022 bool arg3 = (bool) true ;
11023 bool result;
11024 void *argp1 = 0 ;
11025 int res1 = 0 ;
11026 int val2 ;
11027 int ecode2 = 0 ;
11028 bool val3 ;
11029 int ecode3 = 0 ;
11030 PyObject * obj0 = 0 ;
11031 PyObject * obj1 = 0 ;
11032 PyObject * obj2 = 0 ;
11033 char * kwnames[] = {
11034 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11035 };
11036
11037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11039 if (!SWIG_IsOK(res1)) {
11040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11041 }
11042 arg1 = reinterpret_cast< wxGrid * >(argp1);
11043 if (obj1) {
11044 ecode2 = SWIG_AsVal_int(obj1, &val2);
11045 if (!SWIG_IsOK(ecode2)) {
11046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11047 }
11048 arg2 = static_cast< int >(val2);
11049 }
11050 if (obj2) {
11051 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11052 if (!SWIG_IsOK(ecode3)) {
11053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11054 }
11055 arg3 = static_cast< bool >(val3);
11056 }
11057 {
11058 PyThreadState* __tstate = wxPyBeginAllowThreads();
11059 result = (bool)(arg1)->AppendCols(arg2,arg3);
11060 wxPyEndAllowThreads(__tstate);
11061 if (PyErr_Occurred()) SWIG_fail;
11062 }
11063 {
11064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11065 }
11066 return resultobj;
11067 fail:
11068 return NULL;
11069 }
11070
11071
11072 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11073 PyObject *resultobj = 0;
11074 wxGrid *arg1 = (wxGrid *) 0 ;
11075 int arg2 = (int) 0 ;
11076 int arg3 = (int) 1 ;
11077 bool arg4 = (bool) true ;
11078 bool result;
11079 void *argp1 = 0 ;
11080 int res1 = 0 ;
11081 int val2 ;
11082 int ecode2 = 0 ;
11083 int val3 ;
11084 int ecode3 = 0 ;
11085 bool val4 ;
11086 int ecode4 = 0 ;
11087 PyObject * obj0 = 0 ;
11088 PyObject * obj1 = 0 ;
11089 PyObject * obj2 = 0 ;
11090 PyObject * obj3 = 0 ;
11091 char * kwnames[] = {
11092 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11093 };
11094
11095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11097 if (!SWIG_IsOK(res1)) {
11098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11099 }
11100 arg1 = reinterpret_cast< wxGrid * >(argp1);
11101 if (obj1) {
11102 ecode2 = SWIG_AsVal_int(obj1, &val2);
11103 if (!SWIG_IsOK(ecode2)) {
11104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11105 }
11106 arg2 = static_cast< int >(val2);
11107 }
11108 if (obj2) {
11109 ecode3 = SWIG_AsVal_int(obj2, &val3);
11110 if (!SWIG_IsOK(ecode3)) {
11111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11112 }
11113 arg3 = static_cast< int >(val3);
11114 }
11115 if (obj3) {
11116 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11117 if (!SWIG_IsOK(ecode4)) {
11118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11119 }
11120 arg4 = static_cast< bool >(val4);
11121 }
11122 {
11123 PyThreadState* __tstate = wxPyBeginAllowThreads();
11124 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 {
11129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11130 }
11131 return resultobj;
11132 fail:
11133 return NULL;
11134 }
11135
11136
11137 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11138 PyObject *resultobj = 0;
11139 wxGrid *arg1 = (wxGrid *) 0 ;
11140 wxDC *arg2 = 0 ;
11141 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11142 void *argp1 = 0 ;
11143 int res1 = 0 ;
11144 void *argp2 = 0 ;
11145 int res2 = 0 ;
11146 void *argp3 = 0 ;
11147 int res3 = 0 ;
11148 PyObject * obj0 = 0 ;
11149 PyObject * obj1 = 0 ;
11150 PyObject * obj2 = 0 ;
11151 char * kwnames[] = {
11152 (char *) "self",(char *) "dc",(char *) "attr", NULL
11153 };
11154
11155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11157 if (!SWIG_IsOK(res1)) {
11158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11159 }
11160 arg1 = reinterpret_cast< wxGrid * >(argp1);
11161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11162 if (!SWIG_IsOK(res2)) {
11163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11164 }
11165 if (!argp2) {
11166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11167 }
11168 arg2 = reinterpret_cast< wxDC * >(argp2);
11169 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11170 if (!SWIG_IsOK(res3)) {
11171 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11172 }
11173 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11174 {
11175 PyThreadState* __tstate = wxPyBeginAllowThreads();
11176 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11177 wxPyEndAllowThreads(__tstate);
11178 if (PyErr_Occurred()) SWIG_fail;
11179 }
11180 resultobj = SWIG_Py_Void();
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11188 PyObject *resultobj = 0;
11189 wxGrid *arg1 = (wxGrid *) 0 ;
11190 wxDC *arg2 = 0 ;
11191 wxString *arg3 = 0 ;
11192 wxRect *arg4 = 0 ;
11193 int arg5 = (int) wxLEFT ;
11194 int arg6 = (int) wxTOP ;
11195 int arg7 = (int) wxHORIZONTAL ;
11196 void *argp1 = 0 ;
11197 int res1 = 0 ;
11198 void *argp2 = 0 ;
11199 int res2 = 0 ;
11200 bool temp3 = false ;
11201 wxRect temp4 ;
11202 int val5 ;
11203 int ecode5 = 0 ;
11204 int val6 ;
11205 int ecode6 = 0 ;
11206 int val7 ;
11207 int ecode7 = 0 ;
11208 PyObject * obj0 = 0 ;
11209 PyObject * obj1 = 0 ;
11210 PyObject * obj2 = 0 ;
11211 PyObject * obj3 = 0 ;
11212 PyObject * obj4 = 0 ;
11213 PyObject * obj5 = 0 ;
11214 PyObject * obj6 = 0 ;
11215 char * kwnames[] = {
11216 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11217 };
11218
11219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11221 if (!SWIG_IsOK(res1)) {
11222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11223 }
11224 arg1 = reinterpret_cast< wxGrid * >(argp1);
11225 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11226 if (!SWIG_IsOK(res2)) {
11227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11228 }
11229 if (!argp2) {
11230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11231 }
11232 arg2 = reinterpret_cast< wxDC * >(argp2);
11233 {
11234 arg3 = wxString_in_helper(obj2);
11235 if (arg3 == NULL) SWIG_fail;
11236 temp3 = true;
11237 }
11238 {
11239 arg4 = &temp4;
11240 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11241 }
11242 if (obj4) {
11243 ecode5 = SWIG_AsVal_int(obj4, &val5);
11244 if (!SWIG_IsOK(ecode5)) {
11245 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11246 }
11247 arg5 = static_cast< int >(val5);
11248 }
11249 if (obj5) {
11250 ecode6 = SWIG_AsVal_int(obj5, &val6);
11251 if (!SWIG_IsOK(ecode6)) {
11252 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11253 }
11254 arg6 = static_cast< int >(val6);
11255 }
11256 if (obj6) {
11257 ecode7 = SWIG_AsVal_int(obj6, &val7);
11258 if (!SWIG_IsOK(ecode7)) {
11259 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11260 }
11261 arg7 = static_cast< int >(val7);
11262 }
11263 {
11264 PyThreadState* __tstate = wxPyBeginAllowThreads();
11265 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11266 wxPyEndAllowThreads(__tstate);
11267 if (PyErr_Occurred()) SWIG_fail;
11268 }
11269 resultobj = SWIG_Py_Void();
11270 {
11271 if (temp3)
11272 delete arg3;
11273 }
11274 return resultobj;
11275 fail:
11276 {
11277 if (temp3)
11278 delete arg3;
11279 }
11280 return NULL;
11281 }
11282
11283
11284 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11285 PyObject *resultobj = 0;
11286 wxGrid *arg1 = (wxGrid *) 0 ;
11287 wxDC *arg2 = 0 ;
11288 wxArrayString *arg3 = 0 ;
11289 long *arg4 = (long *) 0 ;
11290 long *arg5 = (long *) 0 ;
11291 void *argp1 = 0 ;
11292 int res1 = 0 ;
11293 void *argp2 = 0 ;
11294 int res2 = 0 ;
11295 bool temp3 = false ;
11296 long temp4 ;
11297 int res4 = SWIG_TMPOBJ ;
11298 long temp5 ;
11299 int res5 = SWIG_TMPOBJ ;
11300 PyObject * obj0 = 0 ;
11301 PyObject * obj1 = 0 ;
11302 PyObject * obj2 = 0 ;
11303 char * kwnames[] = {
11304 (char *) "self",(char *) "dc",(char *) "lines", NULL
11305 };
11306
11307 arg4 = &temp4;
11308 arg5 = &temp5;
11309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11311 if (!SWIG_IsOK(res1)) {
11312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11313 }
11314 arg1 = reinterpret_cast< wxGrid * >(argp1);
11315 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11316 if (!SWIG_IsOK(res2)) {
11317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11318 }
11319 if (!argp2) {
11320 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11321 }
11322 arg2 = reinterpret_cast< wxDC * >(argp2);
11323 {
11324 if (! PySequence_Check(obj2)) {
11325 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11326 SWIG_fail;
11327 }
11328 arg3 = new wxArrayString;
11329 temp3 = true;
11330 int i, len=PySequence_Length(obj2);
11331 for (i=0; i<len; i++) {
11332 PyObject* item = PySequence_GetItem(obj2, i);
11333 wxString* s = wxString_in_helper(item);
11334 if (PyErr_Occurred()) SWIG_fail;
11335 arg3->Add(*s);
11336 delete s;
11337 Py_DECREF(item);
11338 }
11339 }
11340 {
11341 PyThreadState* __tstate = wxPyBeginAllowThreads();
11342 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 resultobj = SWIG_Py_Void();
11347 if (SWIG_IsTmpObj(res4)) {
11348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11349 } else {
11350 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11352 }
11353 if (SWIG_IsTmpObj(res5)) {
11354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11355 } else {
11356 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11358 }
11359 {
11360 if (temp3) delete arg3;
11361 }
11362 return resultobj;
11363 fail:
11364 {
11365 if (temp3) delete arg3;
11366 }
11367 return NULL;
11368 }
11369
11370
11371 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11372 PyObject *resultobj = 0;
11373 wxGrid *arg1 = (wxGrid *) 0 ;
11374 void *argp1 = 0 ;
11375 int res1 = 0 ;
11376 PyObject *swig_obj[1] ;
11377
11378 if (!args) SWIG_fail;
11379 swig_obj[0] = args;
11380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11381 if (!SWIG_IsOK(res1)) {
11382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11383 }
11384 arg1 = reinterpret_cast< wxGrid * >(argp1);
11385 {
11386 PyThreadState* __tstate = wxPyBeginAllowThreads();
11387 (arg1)->BeginBatch();
11388 wxPyEndAllowThreads(__tstate);
11389 if (PyErr_Occurred()) SWIG_fail;
11390 }
11391 resultobj = SWIG_Py_Void();
11392 return resultobj;
11393 fail:
11394 return NULL;
11395 }
11396
11397
11398 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11399 PyObject *resultobj = 0;
11400 wxGrid *arg1 = (wxGrid *) 0 ;
11401 void *argp1 = 0 ;
11402 int res1 = 0 ;
11403 PyObject *swig_obj[1] ;
11404
11405 if (!args) SWIG_fail;
11406 swig_obj[0] = args;
11407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11408 if (!SWIG_IsOK(res1)) {
11409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11410 }
11411 arg1 = reinterpret_cast< wxGrid * >(argp1);
11412 {
11413 PyThreadState* __tstate = wxPyBeginAllowThreads();
11414 (arg1)->EndBatch();
11415 wxPyEndAllowThreads(__tstate);
11416 if (PyErr_Occurred()) SWIG_fail;
11417 }
11418 resultobj = SWIG_Py_Void();
11419 return resultobj;
11420 fail:
11421 return NULL;
11422 }
11423
11424
11425 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11426 PyObject *resultobj = 0;
11427 wxGrid *arg1 = (wxGrid *) 0 ;
11428 int result;
11429 void *argp1 = 0 ;
11430 int res1 = 0 ;
11431 PyObject *swig_obj[1] ;
11432
11433 if (!args) SWIG_fail;
11434 swig_obj[0] = args;
11435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11436 if (!SWIG_IsOK(res1)) {
11437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11438 }
11439 arg1 = reinterpret_cast< wxGrid * >(argp1);
11440 {
11441 PyThreadState* __tstate = wxPyBeginAllowThreads();
11442 result = (int)(arg1)->GetBatchCount();
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 resultobj = SWIG_From_int(static_cast< int >(result));
11447 return resultobj;
11448 fail:
11449 return NULL;
11450 }
11451
11452
11453 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11454 PyObject *resultobj = 0;
11455 wxGrid *arg1 = (wxGrid *) 0 ;
11456 void *argp1 = 0 ;
11457 int res1 = 0 ;
11458 PyObject *swig_obj[1] ;
11459
11460 if (!args) SWIG_fail;
11461 swig_obj[0] = args;
11462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11463 if (!SWIG_IsOK(res1)) {
11464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11465 }
11466 arg1 = reinterpret_cast< wxGrid * >(argp1);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 (arg1)->ForceRefresh();
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 return resultobj;
11475 fail:
11476 return NULL;
11477 }
11478
11479
11480 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11481 PyObject *resultobj = 0;
11482 wxGrid *arg1 = (wxGrid *) 0 ;
11483 bool result;
11484 void *argp1 = 0 ;
11485 int res1 = 0 ;
11486 PyObject *swig_obj[1] ;
11487
11488 if (!args) SWIG_fail;
11489 swig_obj[0] = args;
11490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11491 if (!SWIG_IsOK(res1)) {
11492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11493 }
11494 arg1 = reinterpret_cast< wxGrid * >(argp1);
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 result = (bool)(arg1)->IsEditable();
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 {
11502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11503 }
11504 return resultobj;
11505 fail:
11506 return NULL;
11507 }
11508
11509
11510 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11511 PyObject *resultobj = 0;
11512 wxGrid *arg1 = (wxGrid *) 0 ;
11513 bool arg2 ;
11514 void *argp1 = 0 ;
11515 int res1 = 0 ;
11516 bool val2 ;
11517 int ecode2 = 0 ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 char * kwnames[] = {
11521 (char *) "self",(char *) "edit", NULL
11522 };
11523
11524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11526 if (!SWIG_IsOK(res1)) {
11527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11528 }
11529 arg1 = reinterpret_cast< wxGrid * >(argp1);
11530 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11531 if (!SWIG_IsOK(ecode2)) {
11532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11533 }
11534 arg2 = static_cast< bool >(val2);
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 (arg1)->EnableEditing(arg2);
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 resultobj = SWIG_Py_Void();
11542 return resultobj;
11543 fail:
11544 return NULL;
11545 }
11546
11547
11548 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11549 PyObject *resultobj = 0;
11550 wxGrid *arg1 = (wxGrid *) 0 ;
11551 bool arg2 = (bool) true ;
11552 void *argp1 = 0 ;
11553 int res1 = 0 ;
11554 bool val2 ;
11555 int ecode2 = 0 ;
11556 PyObject * obj0 = 0 ;
11557 PyObject * obj1 = 0 ;
11558 char * kwnames[] = {
11559 (char *) "self",(char *) "enable", NULL
11560 };
11561
11562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11564 if (!SWIG_IsOK(res1)) {
11565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11566 }
11567 arg1 = reinterpret_cast< wxGrid * >(argp1);
11568 if (obj1) {
11569 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11570 if (!SWIG_IsOK(ecode2)) {
11571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11572 }
11573 arg2 = static_cast< bool >(val2);
11574 }
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 (arg1)->EnableCellEditControl(arg2);
11578 wxPyEndAllowThreads(__tstate);
11579 if (PyErr_Occurred()) SWIG_fail;
11580 }
11581 resultobj = SWIG_Py_Void();
11582 return resultobj;
11583 fail:
11584 return NULL;
11585 }
11586
11587
11588 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11589 PyObject *resultobj = 0;
11590 wxGrid *arg1 = (wxGrid *) 0 ;
11591 void *argp1 = 0 ;
11592 int res1 = 0 ;
11593 PyObject *swig_obj[1] ;
11594
11595 if (!args) SWIG_fail;
11596 swig_obj[0] = args;
11597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11598 if (!SWIG_IsOK(res1)) {
11599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11600 }
11601 arg1 = reinterpret_cast< wxGrid * >(argp1);
11602 {
11603 PyThreadState* __tstate = wxPyBeginAllowThreads();
11604 (arg1)->DisableCellEditControl();
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 resultobj = SWIG_Py_Void();
11609 return resultobj;
11610 fail:
11611 return NULL;
11612 }
11613
11614
11615 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11616 PyObject *resultobj = 0;
11617 wxGrid *arg1 = (wxGrid *) 0 ;
11618 bool result;
11619 void *argp1 = 0 ;
11620 int res1 = 0 ;
11621 PyObject *swig_obj[1] ;
11622
11623 if (!args) SWIG_fail;
11624 swig_obj[0] = args;
11625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11626 if (!SWIG_IsOK(res1)) {
11627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11628 }
11629 arg1 = reinterpret_cast< wxGrid * >(argp1);
11630 {
11631 PyThreadState* __tstate = wxPyBeginAllowThreads();
11632 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11633 wxPyEndAllowThreads(__tstate);
11634 if (PyErr_Occurred()) SWIG_fail;
11635 }
11636 {
11637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11638 }
11639 return resultobj;
11640 fail:
11641 return NULL;
11642 }
11643
11644
11645 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11646 PyObject *resultobj = 0;
11647 wxGrid *arg1 = (wxGrid *) 0 ;
11648 bool result;
11649 void *argp1 = 0 ;
11650 int res1 = 0 ;
11651 PyObject *swig_obj[1] ;
11652
11653 if (!args) SWIG_fail;
11654 swig_obj[0] = args;
11655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11656 if (!SWIG_IsOK(res1)) {
11657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11658 }
11659 arg1 = reinterpret_cast< wxGrid * >(argp1);
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 {
11667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11668 }
11669 return resultobj;
11670 fail:
11671 return NULL;
11672 }
11673
11674
11675 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11676 PyObject *resultobj = 0;
11677 wxGrid *arg1 = (wxGrid *) 0 ;
11678 bool result;
11679 void *argp1 = 0 ;
11680 int res1 = 0 ;
11681 PyObject *swig_obj[1] ;
11682
11683 if (!args) SWIG_fail;
11684 swig_obj[0] = args;
11685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11686 if (!SWIG_IsOK(res1)) {
11687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11688 }
11689 arg1 = reinterpret_cast< wxGrid * >(argp1);
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 {
11697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11698 }
11699 return resultobj;
11700 fail:
11701 return NULL;
11702 }
11703
11704
11705 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11706 PyObject *resultobj = 0;
11707 wxGrid *arg1 = (wxGrid *) 0 ;
11708 bool result;
11709 void *argp1 = 0 ;
11710 int res1 = 0 ;
11711 PyObject *swig_obj[1] ;
11712
11713 if (!args) SWIG_fail;
11714 swig_obj[0] = args;
11715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11716 if (!SWIG_IsOK(res1)) {
11717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11718 }
11719 arg1 = reinterpret_cast< wxGrid * >(argp1);
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11723 wxPyEndAllowThreads(__tstate);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 {
11727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11728 }
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11736 PyObject *resultobj = 0;
11737 wxGrid *arg1 = (wxGrid *) 0 ;
11738 void *argp1 = 0 ;
11739 int res1 = 0 ;
11740 PyObject *swig_obj[1] ;
11741
11742 if (!args) SWIG_fail;
11743 swig_obj[0] = args;
11744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11745 if (!SWIG_IsOK(res1)) {
11746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11747 }
11748 arg1 = reinterpret_cast< wxGrid * >(argp1);
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 (arg1)->ShowCellEditControl();
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_Py_Void();
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxGrid *arg1 = (wxGrid *) 0 ;
11765 void *argp1 = 0 ;
11766 int res1 = 0 ;
11767 PyObject *swig_obj[1] ;
11768
11769 if (!args) SWIG_fail;
11770 swig_obj[0] = args;
11771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11772 if (!SWIG_IsOK(res1)) {
11773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11774 }
11775 arg1 = reinterpret_cast< wxGrid * >(argp1);
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 (arg1)->HideCellEditControl();
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 resultobj = SWIG_Py_Void();
11783 return resultobj;
11784 fail:
11785 return NULL;
11786 }
11787
11788
11789 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11790 PyObject *resultobj = 0;
11791 wxGrid *arg1 = (wxGrid *) 0 ;
11792 void *argp1 = 0 ;
11793 int res1 = 0 ;
11794 PyObject *swig_obj[1] ;
11795
11796 if (!args) SWIG_fail;
11797 swig_obj[0] = args;
11798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11799 if (!SWIG_IsOK(res1)) {
11800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11801 }
11802 arg1 = reinterpret_cast< wxGrid * >(argp1);
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 (arg1)->SaveEditControlValue();
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 resultobj = SWIG_Py_Void();
11810 return resultobj;
11811 fail:
11812 return NULL;
11813 }
11814
11815
11816 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11817 PyObject *resultobj = 0;
11818 wxGrid *arg1 = (wxGrid *) 0 ;
11819 int arg2 ;
11820 int arg3 ;
11821 wxGridCellCoords result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 int val2 ;
11825 int ecode2 = 0 ;
11826 int val3 ;
11827 int ecode3 = 0 ;
11828 PyObject * obj0 = 0 ;
11829 PyObject * obj1 = 0 ;
11830 PyObject * obj2 = 0 ;
11831 char * kwnames[] = {
11832 (char *) "self",(char *) "x",(char *) "y", NULL
11833 };
11834
11835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11837 if (!SWIG_IsOK(res1)) {
11838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11839 }
11840 arg1 = reinterpret_cast< wxGrid * >(argp1);
11841 ecode2 = SWIG_AsVal_int(obj1, &val2);
11842 if (!SWIG_IsOK(ecode2)) {
11843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11844 }
11845 arg2 = static_cast< int >(val2);
11846 ecode3 = SWIG_AsVal_int(obj2, &val3);
11847 if (!SWIG_IsOK(ecode3)) {
11848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11849 }
11850 arg3 = static_cast< int >(val3);
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = wxGrid_XYToCell(arg1,arg2,arg3);
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11865 PyObject *resultobj = 0;
11866 wxGrid *arg1 = (wxGrid *) 0 ;
11867 int arg2 ;
11868 int result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 int val2 ;
11872 int ecode2 = 0 ;
11873 PyObject * obj0 = 0 ;
11874 PyObject * obj1 = 0 ;
11875 char * kwnames[] = {
11876 (char *) "self",(char *) "y", NULL
11877 };
11878
11879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11881 if (!SWIG_IsOK(res1)) {
11882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11883 }
11884 arg1 = reinterpret_cast< wxGrid * >(argp1);
11885 ecode2 = SWIG_AsVal_int(obj1, &val2);
11886 if (!SWIG_IsOK(ecode2)) {
11887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11888 }
11889 arg2 = static_cast< int >(val2);
11890 {
11891 PyThreadState* __tstate = wxPyBeginAllowThreads();
11892 result = (int)(arg1)->YToRow(arg2);
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 resultobj = SWIG_From_int(static_cast< int >(result));
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj = 0;
11905 wxGrid *arg1 = (wxGrid *) 0 ;
11906 int arg2 ;
11907 bool arg3 = (bool) false ;
11908 int result;
11909 void *argp1 = 0 ;
11910 int res1 = 0 ;
11911 int val2 ;
11912 int ecode2 = 0 ;
11913 bool val3 ;
11914 int ecode3 = 0 ;
11915 PyObject * obj0 = 0 ;
11916 PyObject * obj1 = 0 ;
11917 PyObject * obj2 = 0 ;
11918 char * kwnames[] = {
11919 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
11920 };
11921
11922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11924 if (!SWIG_IsOK(res1)) {
11925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11926 }
11927 arg1 = reinterpret_cast< wxGrid * >(argp1);
11928 ecode2 = SWIG_AsVal_int(obj1, &val2);
11929 if (!SWIG_IsOK(ecode2)) {
11930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11931 }
11932 arg2 = static_cast< int >(val2);
11933 if (obj2) {
11934 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11935 if (!SWIG_IsOK(ecode3)) {
11936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
11937 }
11938 arg3 = static_cast< bool >(val3);
11939 }
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (int)(arg1)->XToCol(arg2,arg3);
11943 wxPyEndAllowThreads(__tstate);
11944 if (PyErr_Occurred()) SWIG_fail;
11945 }
11946 resultobj = SWIG_From_int(static_cast< int >(result));
11947 return resultobj;
11948 fail:
11949 return NULL;
11950 }
11951
11952
11953 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11954 PyObject *resultobj = 0;
11955 wxGrid *arg1 = (wxGrid *) 0 ;
11956 int arg2 ;
11957 int result;
11958 void *argp1 = 0 ;
11959 int res1 = 0 ;
11960 int val2 ;
11961 int ecode2 = 0 ;
11962 PyObject * obj0 = 0 ;
11963 PyObject * obj1 = 0 ;
11964 char * kwnames[] = {
11965 (char *) "self",(char *) "y", NULL
11966 };
11967
11968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11970 if (!SWIG_IsOK(res1)) {
11971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11972 }
11973 arg1 = reinterpret_cast< wxGrid * >(argp1);
11974 ecode2 = SWIG_AsVal_int(obj1, &val2);
11975 if (!SWIG_IsOK(ecode2)) {
11976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11977 }
11978 arg2 = static_cast< int >(val2);
11979 {
11980 PyThreadState* __tstate = wxPyBeginAllowThreads();
11981 result = (int)(arg1)->YToEdgeOfRow(arg2);
11982 wxPyEndAllowThreads(__tstate);
11983 if (PyErr_Occurred()) SWIG_fail;
11984 }
11985 resultobj = SWIG_From_int(static_cast< int >(result));
11986 return resultobj;
11987 fail:
11988 return NULL;
11989 }
11990
11991
11992 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11993 PyObject *resultobj = 0;
11994 wxGrid *arg1 = (wxGrid *) 0 ;
11995 int arg2 ;
11996 int result;
11997 void *argp1 = 0 ;
11998 int res1 = 0 ;
11999 int val2 ;
12000 int ecode2 = 0 ;
12001 PyObject * obj0 = 0 ;
12002 PyObject * obj1 = 0 ;
12003 char * kwnames[] = {
12004 (char *) "self",(char *) "x", NULL
12005 };
12006
12007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12009 if (!SWIG_IsOK(res1)) {
12010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12011 }
12012 arg1 = reinterpret_cast< wxGrid * >(argp1);
12013 ecode2 = SWIG_AsVal_int(obj1, &val2);
12014 if (!SWIG_IsOK(ecode2)) {
12015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12016 }
12017 arg2 = static_cast< int >(val2);
12018 {
12019 PyThreadState* __tstate = wxPyBeginAllowThreads();
12020 result = (int)(arg1)->XToEdgeOfCol(arg2);
12021 wxPyEndAllowThreads(__tstate);
12022 if (PyErr_Occurred()) SWIG_fail;
12023 }
12024 resultobj = SWIG_From_int(static_cast< int >(result));
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj = 0;
12033 wxGrid *arg1 = (wxGrid *) 0 ;
12034 int arg2 ;
12035 int arg3 ;
12036 wxRect result;
12037 void *argp1 = 0 ;
12038 int res1 = 0 ;
12039 int val2 ;
12040 int ecode2 = 0 ;
12041 int val3 ;
12042 int ecode3 = 0 ;
12043 PyObject * obj0 = 0 ;
12044 PyObject * obj1 = 0 ;
12045 PyObject * obj2 = 0 ;
12046 char * kwnames[] = {
12047 (char *) "self",(char *) "row",(char *) "col", NULL
12048 };
12049
12050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12052 if (!SWIG_IsOK(res1)) {
12053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12054 }
12055 arg1 = reinterpret_cast< wxGrid * >(argp1);
12056 ecode2 = SWIG_AsVal_int(obj1, &val2);
12057 if (!SWIG_IsOK(ecode2)) {
12058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12059 }
12060 arg2 = static_cast< int >(val2);
12061 ecode3 = SWIG_AsVal_int(obj2, &val3);
12062 if (!SWIG_IsOK(ecode3)) {
12063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12064 }
12065 arg3 = static_cast< int >(val3);
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 result = (arg1)->CellToRect(arg2,arg3);
12069 wxPyEndAllowThreads(__tstate);
12070 if (PyErr_Occurred()) SWIG_fail;
12071 }
12072 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12073 return resultobj;
12074 fail:
12075 return NULL;
12076 }
12077
12078
12079 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12080 PyObject *resultobj = 0;
12081 wxGrid *arg1 = (wxGrid *) 0 ;
12082 int result;
12083 void *argp1 = 0 ;
12084 int res1 = 0 ;
12085 PyObject *swig_obj[1] ;
12086
12087 if (!args) SWIG_fail;
12088 swig_obj[0] = args;
12089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12090 if (!SWIG_IsOK(res1)) {
12091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12092 }
12093 arg1 = reinterpret_cast< wxGrid * >(argp1);
12094 {
12095 PyThreadState* __tstate = wxPyBeginAllowThreads();
12096 result = (int)(arg1)->GetGridCursorRow();
12097 wxPyEndAllowThreads(__tstate);
12098 if (PyErr_Occurred()) SWIG_fail;
12099 }
12100 resultobj = SWIG_From_int(static_cast< int >(result));
12101 return resultobj;
12102 fail:
12103 return NULL;
12104 }
12105
12106
12107 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12108 PyObject *resultobj = 0;
12109 wxGrid *arg1 = (wxGrid *) 0 ;
12110 int result;
12111 void *argp1 = 0 ;
12112 int res1 = 0 ;
12113 PyObject *swig_obj[1] ;
12114
12115 if (!args) SWIG_fail;
12116 swig_obj[0] = args;
12117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12118 if (!SWIG_IsOK(res1)) {
12119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12120 }
12121 arg1 = reinterpret_cast< wxGrid * >(argp1);
12122 {
12123 PyThreadState* __tstate = wxPyBeginAllowThreads();
12124 result = (int)(arg1)->GetGridCursorCol();
12125 wxPyEndAllowThreads(__tstate);
12126 if (PyErr_Occurred()) SWIG_fail;
12127 }
12128 resultobj = SWIG_From_int(static_cast< int >(result));
12129 return resultobj;
12130 fail:
12131 return NULL;
12132 }
12133
12134
12135 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12136 PyObject *resultobj = 0;
12137 wxGrid *arg1 = (wxGrid *) 0 ;
12138 int arg2 ;
12139 int arg3 ;
12140 bool arg4 = (bool) true ;
12141 bool result;
12142 void *argp1 = 0 ;
12143 int res1 = 0 ;
12144 int val2 ;
12145 int ecode2 = 0 ;
12146 int val3 ;
12147 int ecode3 = 0 ;
12148 bool val4 ;
12149 int ecode4 = 0 ;
12150 PyObject * obj0 = 0 ;
12151 PyObject * obj1 = 0 ;
12152 PyObject * obj2 = 0 ;
12153 PyObject * obj3 = 0 ;
12154 char * kwnames[] = {
12155 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12156 };
12157
12158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12160 if (!SWIG_IsOK(res1)) {
12161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12162 }
12163 arg1 = reinterpret_cast< wxGrid * >(argp1);
12164 ecode2 = SWIG_AsVal_int(obj1, &val2);
12165 if (!SWIG_IsOK(ecode2)) {
12166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12167 }
12168 arg2 = static_cast< int >(val2);
12169 ecode3 = SWIG_AsVal_int(obj2, &val3);
12170 if (!SWIG_IsOK(ecode3)) {
12171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12172 }
12173 arg3 = static_cast< int >(val3);
12174 if (obj3) {
12175 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12176 if (!SWIG_IsOK(ecode4)) {
12177 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12178 }
12179 arg4 = static_cast< bool >(val4);
12180 }
12181 {
12182 PyThreadState* __tstate = wxPyBeginAllowThreads();
12183 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12184 wxPyEndAllowThreads(__tstate);
12185 if (PyErr_Occurred()) SWIG_fail;
12186 }
12187 {
12188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12189 }
12190 return resultobj;
12191 fail:
12192 return NULL;
12193 }
12194
12195
12196 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12197 PyObject *resultobj = 0;
12198 wxGrid *arg1 = (wxGrid *) 0 ;
12199 int arg2 ;
12200 int arg3 ;
12201 void *argp1 = 0 ;
12202 int res1 = 0 ;
12203 int val2 ;
12204 int ecode2 = 0 ;
12205 int val3 ;
12206 int ecode3 = 0 ;
12207 PyObject * obj0 = 0 ;
12208 PyObject * obj1 = 0 ;
12209 PyObject * obj2 = 0 ;
12210 char * kwnames[] = {
12211 (char *) "self",(char *) "row",(char *) "col", NULL
12212 };
12213
12214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12216 if (!SWIG_IsOK(res1)) {
12217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12218 }
12219 arg1 = reinterpret_cast< wxGrid * >(argp1);
12220 ecode2 = SWIG_AsVal_int(obj1, &val2);
12221 if (!SWIG_IsOK(ecode2)) {
12222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12223 }
12224 arg2 = static_cast< int >(val2);
12225 ecode3 = SWIG_AsVal_int(obj2, &val3);
12226 if (!SWIG_IsOK(ecode3)) {
12227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12228 }
12229 arg3 = static_cast< int >(val3);
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 (arg1)->MakeCellVisible(arg2,arg3);
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 resultobj = SWIG_Py_Void();
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj = 0;
12245 wxGrid *arg1 = (wxGrid *) 0 ;
12246 int arg2 ;
12247 int arg3 ;
12248 void *argp1 = 0 ;
12249 int res1 = 0 ;
12250 int val2 ;
12251 int ecode2 = 0 ;
12252 int val3 ;
12253 int ecode3 = 0 ;
12254 PyObject * obj0 = 0 ;
12255 PyObject * obj1 = 0 ;
12256 PyObject * obj2 = 0 ;
12257 char * kwnames[] = {
12258 (char *) "self",(char *) "row",(char *) "col", NULL
12259 };
12260
12261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12263 if (!SWIG_IsOK(res1)) {
12264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12265 }
12266 arg1 = reinterpret_cast< wxGrid * >(argp1);
12267 ecode2 = SWIG_AsVal_int(obj1, &val2);
12268 if (!SWIG_IsOK(ecode2)) {
12269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12270 }
12271 arg2 = static_cast< int >(val2);
12272 ecode3 = SWIG_AsVal_int(obj2, &val3);
12273 if (!SWIG_IsOK(ecode3)) {
12274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12275 }
12276 arg3 = static_cast< int >(val3);
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 (arg1)->SetGridCursor(arg2,arg3);
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 resultobj = SWIG_Py_Void();
12284 return resultobj;
12285 fail:
12286 return NULL;
12287 }
12288
12289
12290 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12291 PyObject *resultobj = 0;
12292 wxGrid *arg1 = (wxGrid *) 0 ;
12293 bool arg2 ;
12294 bool result;
12295 void *argp1 = 0 ;
12296 int res1 = 0 ;
12297 bool val2 ;
12298 int ecode2 = 0 ;
12299 PyObject * obj0 = 0 ;
12300 PyObject * obj1 = 0 ;
12301 char * kwnames[] = {
12302 (char *) "self",(char *) "expandSelection", NULL
12303 };
12304
12305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12307 if (!SWIG_IsOK(res1)) {
12308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12309 }
12310 arg1 = reinterpret_cast< wxGrid * >(argp1);
12311 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12312 if (!SWIG_IsOK(ecode2)) {
12313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12314 }
12315 arg2 = static_cast< bool >(val2);
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 result = (bool)(arg1)->MoveCursorUp(arg2);
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12324 }
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12332 PyObject *resultobj = 0;
12333 wxGrid *arg1 = (wxGrid *) 0 ;
12334 bool arg2 ;
12335 bool result;
12336 void *argp1 = 0 ;
12337 int res1 = 0 ;
12338 bool val2 ;
12339 int ecode2 = 0 ;
12340 PyObject * obj0 = 0 ;
12341 PyObject * obj1 = 0 ;
12342 char * kwnames[] = {
12343 (char *) "self",(char *) "expandSelection", NULL
12344 };
12345
12346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12348 if (!SWIG_IsOK(res1)) {
12349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12350 }
12351 arg1 = reinterpret_cast< wxGrid * >(argp1);
12352 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12353 if (!SWIG_IsOK(ecode2)) {
12354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12355 }
12356 arg2 = static_cast< bool >(val2);
12357 {
12358 PyThreadState* __tstate = wxPyBeginAllowThreads();
12359 result = (bool)(arg1)->MoveCursorDown(arg2);
12360 wxPyEndAllowThreads(__tstate);
12361 if (PyErr_Occurred()) SWIG_fail;
12362 }
12363 {
12364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12365 }
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12373 PyObject *resultobj = 0;
12374 wxGrid *arg1 = (wxGrid *) 0 ;
12375 bool arg2 ;
12376 bool result;
12377 void *argp1 = 0 ;
12378 int res1 = 0 ;
12379 bool val2 ;
12380 int ecode2 = 0 ;
12381 PyObject * obj0 = 0 ;
12382 PyObject * obj1 = 0 ;
12383 char * kwnames[] = {
12384 (char *) "self",(char *) "expandSelection", NULL
12385 };
12386
12387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12389 if (!SWIG_IsOK(res1)) {
12390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12391 }
12392 arg1 = reinterpret_cast< wxGrid * >(argp1);
12393 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12394 if (!SWIG_IsOK(ecode2)) {
12395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12396 }
12397 arg2 = static_cast< bool >(val2);
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 result = (bool)(arg1)->MoveCursorLeft(arg2);
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 {
12405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12406 }
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj = 0;
12415 wxGrid *arg1 = (wxGrid *) 0 ;
12416 bool arg2 ;
12417 bool result;
12418 void *argp1 = 0 ;
12419 int res1 = 0 ;
12420 bool val2 ;
12421 int ecode2 = 0 ;
12422 PyObject * obj0 = 0 ;
12423 PyObject * obj1 = 0 ;
12424 char * kwnames[] = {
12425 (char *) "self",(char *) "expandSelection", NULL
12426 };
12427
12428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12430 if (!SWIG_IsOK(res1)) {
12431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12432 }
12433 arg1 = reinterpret_cast< wxGrid * >(argp1);
12434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12435 if (!SWIG_IsOK(ecode2)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12437 }
12438 arg2 = static_cast< bool >(val2);
12439 {
12440 PyThreadState* __tstate = wxPyBeginAllowThreads();
12441 result = (bool)(arg1)->MoveCursorRight(arg2);
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 {
12446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12447 }
12448 return resultobj;
12449 fail:
12450 return NULL;
12451 }
12452
12453
12454 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12455 PyObject *resultobj = 0;
12456 wxGrid *arg1 = (wxGrid *) 0 ;
12457 bool result;
12458 void *argp1 = 0 ;
12459 int res1 = 0 ;
12460 PyObject *swig_obj[1] ;
12461
12462 if (!args) SWIG_fail;
12463 swig_obj[0] = args;
12464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12465 if (!SWIG_IsOK(res1)) {
12466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12467 }
12468 arg1 = reinterpret_cast< wxGrid * >(argp1);
12469 {
12470 PyThreadState* __tstate = wxPyBeginAllowThreads();
12471 result = (bool)(arg1)->MovePageDown();
12472 wxPyEndAllowThreads(__tstate);
12473 if (PyErr_Occurred()) SWIG_fail;
12474 }
12475 {
12476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12477 }
12478 return resultobj;
12479 fail:
12480 return NULL;
12481 }
12482
12483
12484 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12485 PyObject *resultobj = 0;
12486 wxGrid *arg1 = (wxGrid *) 0 ;
12487 bool result;
12488 void *argp1 = 0 ;
12489 int res1 = 0 ;
12490 PyObject *swig_obj[1] ;
12491
12492 if (!args) SWIG_fail;
12493 swig_obj[0] = args;
12494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12495 if (!SWIG_IsOK(res1)) {
12496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12497 }
12498 arg1 = reinterpret_cast< wxGrid * >(argp1);
12499 {
12500 PyThreadState* __tstate = wxPyBeginAllowThreads();
12501 result = (bool)(arg1)->MovePageUp();
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 {
12506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12507 }
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12515 PyObject *resultobj = 0;
12516 wxGrid *arg1 = (wxGrid *) 0 ;
12517 bool arg2 ;
12518 bool result;
12519 void *argp1 = 0 ;
12520 int res1 = 0 ;
12521 bool val2 ;
12522 int ecode2 = 0 ;
12523 PyObject * obj0 = 0 ;
12524 PyObject * obj1 = 0 ;
12525 char * kwnames[] = {
12526 (char *) "self",(char *) "expandSelection", NULL
12527 };
12528
12529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12531 if (!SWIG_IsOK(res1)) {
12532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12533 }
12534 arg1 = reinterpret_cast< wxGrid * >(argp1);
12535 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12536 if (!SWIG_IsOK(ecode2)) {
12537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12538 }
12539 arg2 = static_cast< bool >(val2);
12540 {
12541 PyThreadState* __tstate = wxPyBeginAllowThreads();
12542 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 {
12547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12548 }
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12556 PyObject *resultobj = 0;
12557 wxGrid *arg1 = (wxGrid *) 0 ;
12558 bool arg2 ;
12559 bool result;
12560 void *argp1 = 0 ;
12561 int res1 = 0 ;
12562 bool val2 ;
12563 int ecode2 = 0 ;
12564 PyObject * obj0 = 0 ;
12565 PyObject * obj1 = 0 ;
12566 char * kwnames[] = {
12567 (char *) "self",(char *) "expandSelection", NULL
12568 };
12569
12570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12572 if (!SWIG_IsOK(res1)) {
12573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12574 }
12575 arg1 = reinterpret_cast< wxGrid * >(argp1);
12576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12577 if (!SWIG_IsOK(ecode2)) {
12578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12579 }
12580 arg2 = static_cast< bool >(val2);
12581 {
12582 PyThreadState* __tstate = wxPyBeginAllowThreads();
12583 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12584 wxPyEndAllowThreads(__tstate);
12585 if (PyErr_Occurred()) SWIG_fail;
12586 }
12587 {
12588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12589 }
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj = 0;
12598 wxGrid *arg1 = (wxGrid *) 0 ;
12599 bool arg2 ;
12600 bool result;
12601 void *argp1 = 0 ;
12602 int res1 = 0 ;
12603 bool val2 ;
12604 int ecode2 = 0 ;
12605 PyObject * obj0 = 0 ;
12606 PyObject * obj1 = 0 ;
12607 char * kwnames[] = {
12608 (char *) "self",(char *) "expandSelection", NULL
12609 };
12610
12611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12613 if (!SWIG_IsOK(res1)) {
12614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12615 }
12616 arg1 = reinterpret_cast< wxGrid * >(argp1);
12617 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12618 if (!SWIG_IsOK(ecode2)) {
12619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12620 }
12621 arg2 = static_cast< bool >(val2);
12622 {
12623 PyThreadState* __tstate = wxPyBeginAllowThreads();
12624 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 {
12629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12630 }
12631 return resultobj;
12632 fail:
12633 return NULL;
12634 }
12635
12636
12637 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12638 PyObject *resultobj = 0;
12639 wxGrid *arg1 = (wxGrid *) 0 ;
12640 bool arg2 ;
12641 bool result;
12642 void *argp1 = 0 ;
12643 int res1 = 0 ;
12644 bool val2 ;
12645 int ecode2 = 0 ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 char * kwnames[] = {
12649 (char *) "self",(char *) "expandSelection", NULL
12650 };
12651
12652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12654 if (!SWIG_IsOK(res1)) {
12655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12656 }
12657 arg1 = reinterpret_cast< wxGrid * >(argp1);
12658 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12659 if (!SWIG_IsOK(ecode2)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12661 }
12662 arg2 = static_cast< bool >(val2);
12663 {
12664 PyThreadState* __tstate = wxPyBeginAllowThreads();
12665 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 {
12670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12671 }
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12679 PyObject *resultobj = 0;
12680 wxGrid *arg1 = (wxGrid *) 0 ;
12681 int result;
12682 void *argp1 = 0 ;
12683 int res1 = 0 ;
12684 PyObject *swig_obj[1] ;
12685
12686 if (!args) SWIG_fail;
12687 swig_obj[0] = args;
12688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12689 if (!SWIG_IsOK(res1)) {
12690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12691 }
12692 arg1 = reinterpret_cast< wxGrid * >(argp1);
12693 {
12694 PyThreadState* __tstate = wxPyBeginAllowThreads();
12695 result = (int)(arg1)->GetDefaultRowLabelSize();
12696 wxPyEndAllowThreads(__tstate);
12697 if (PyErr_Occurred()) SWIG_fail;
12698 }
12699 resultobj = SWIG_From_int(static_cast< int >(result));
12700 return resultobj;
12701 fail:
12702 return NULL;
12703 }
12704
12705
12706 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12707 PyObject *resultobj = 0;
12708 wxGrid *arg1 = (wxGrid *) 0 ;
12709 int result;
12710 void *argp1 = 0 ;
12711 int res1 = 0 ;
12712 PyObject *swig_obj[1] ;
12713
12714 if (!args) SWIG_fail;
12715 swig_obj[0] = args;
12716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12717 if (!SWIG_IsOK(res1)) {
12718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12719 }
12720 arg1 = reinterpret_cast< wxGrid * >(argp1);
12721 {
12722 PyThreadState* __tstate = wxPyBeginAllowThreads();
12723 result = (int)(arg1)->GetRowLabelSize();
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 resultobj = SWIG_From_int(static_cast< int >(result));
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12735 PyObject *resultobj = 0;
12736 wxGrid *arg1 = (wxGrid *) 0 ;
12737 int result;
12738 void *argp1 = 0 ;
12739 int res1 = 0 ;
12740 PyObject *swig_obj[1] ;
12741
12742 if (!args) SWIG_fail;
12743 swig_obj[0] = args;
12744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12745 if (!SWIG_IsOK(res1)) {
12746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12747 }
12748 arg1 = reinterpret_cast< wxGrid * >(argp1);
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 result = (int)(arg1)->GetDefaultColLabelSize();
12752 wxPyEndAllowThreads(__tstate);
12753 if (PyErr_Occurred()) SWIG_fail;
12754 }
12755 resultobj = SWIG_From_int(static_cast< int >(result));
12756 return resultobj;
12757 fail:
12758 return NULL;
12759 }
12760
12761
12762 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12763 PyObject *resultobj = 0;
12764 wxGrid *arg1 = (wxGrid *) 0 ;
12765 int result;
12766 void *argp1 = 0 ;
12767 int res1 = 0 ;
12768 PyObject *swig_obj[1] ;
12769
12770 if (!args) SWIG_fail;
12771 swig_obj[0] = args;
12772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12773 if (!SWIG_IsOK(res1)) {
12774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12775 }
12776 arg1 = reinterpret_cast< wxGrid * >(argp1);
12777 {
12778 PyThreadState* __tstate = wxPyBeginAllowThreads();
12779 result = (int)(arg1)->GetColLabelSize();
12780 wxPyEndAllowThreads(__tstate);
12781 if (PyErr_Occurred()) SWIG_fail;
12782 }
12783 resultobj = SWIG_From_int(static_cast< int >(result));
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12791 PyObject *resultobj = 0;
12792 wxGrid *arg1 = (wxGrid *) 0 ;
12793 wxColour result;
12794 void *argp1 = 0 ;
12795 int res1 = 0 ;
12796 PyObject *swig_obj[1] ;
12797
12798 if (!args) SWIG_fail;
12799 swig_obj[0] = args;
12800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12801 if (!SWIG_IsOK(res1)) {
12802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12803 }
12804 arg1 = reinterpret_cast< wxGrid * >(argp1);
12805 {
12806 PyThreadState* __tstate = wxPyBeginAllowThreads();
12807 result = (arg1)->GetLabelBackgroundColour();
12808 wxPyEndAllowThreads(__tstate);
12809 if (PyErr_Occurred()) SWIG_fail;
12810 }
12811 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12812 return resultobj;
12813 fail:
12814 return NULL;
12815 }
12816
12817
12818 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12819 PyObject *resultobj = 0;
12820 wxGrid *arg1 = (wxGrid *) 0 ;
12821 wxColour result;
12822 void *argp1 = 0 ;
12823 int res1 = 0 ;
12824 PyObject *swig_obj[1] ;
12825
12826 if (!args) SWIG_fail;
12827 swig_obj[0] = args;
12828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12829 if (!SWIG_IsOK(res1)) {
12830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12831 }
12832 arg1 = reinterpret_cast< wxGrid * >(argp1);
12833 {
12834 PyThreadState* __tstate = wxPyBeginAllowThreads();
12835 result = (arg1)->GetLabelTextColour();
12836 wxPyEndAllowThreads(__tstate);
12837 if (PyErr_Occurred()) SWIG_fail;
12838 }
12839 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12840 return resultobj;
12841 fail:
12842 return NULL;
12843 }
12844
12845
12846 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12847 PyObject *resultobj = 0;
12848 wxGrid *arg1 = (wxGrid *) 0 ;
12849 wxFont result;
12850 void *argp1 = 0 ;
12851 int res1 = 0 ;
12852 PyObject *swig_obj[1] ;
12853
12854 if (!args) SWIG_fail;
12855 swig_obj[0] = args;
12856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12857 if (!SWIG_IsOK(res1)) {
12858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12859 }
12860 arg1 = reinterpret_cast< wxGrid * >(argp1);
12861 {
12862 PyThreadState* __tstate = wxPyBeginAllowThreads();
12863 result = (arg1)->GetLabelFont();
12864 wxPyEndAllowThreads(__tstate);
12865 if (PyErr_Occurred()) SWIG_fail;
12866 }
12867 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12868 return resultobj;
12869 fail:
12870 return NULL;
12871 }
12872
12873
12874 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12875 PyObject *resultobj = 0;
12876 wxGrid *arg1 = (wxGrid *) 0 ;
12877 int *arg2 = (int *) 0 ;
12878 int *arg3 = (int *) 0 ;
12879 void *argp1 = 0 ;
12880 int res1 = 0 ;
12881 int temp2 ;
12882 int res2 = SWIG_TMPOBJ ;
12883 int temp3 ;
12884 int res3 = SWIG_TMPOBJ ;
12885 PyObject *swig_obj[1] ;
12886
12887 arg2 = &temp2;
12888 arg3 = &temp3;
12889 if (!args) SWIG_fail;
12890 swig_obj[0] = args;
12891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12892 if (!SWIG_IsOK(res1)) {
12893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12894 }
12895 arg1 = reinterpret_cast< wxGrid * >(argp1);
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 (arg1)->GetRowLabelAlignment(arg2,arg3);
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 resultobj = SWIG_Py_Void();
12903 if (SWIG_IsTmpObj(res2)) {
12904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12905 } else {
12906 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12908 }
12909 if (SWIG_IsTmpObj(res3)) {
12910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12911 } else {
12912 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12914 }
12915 return resultobj;
12916 fail:
12917 return NULL;
12918 }
12919
12920
12921 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12922 PyObject *resultobj = 0;
12923 wxGrid *arg1 = (wxGrid *) 0 ;
12924 int *arg2 = (int *) 0 ;
12925 int *arg3 = (int *) 0 ;
12926 void *argp1 = 0 ;
12927 int res1 = 0 ;
12928 int temp2 ;
12929 int res2 = SWIG_TMPOBJ ;
12930 int temp3 ;
12931 int res3 = SWIG_TMPOBJ ;
12932 PyObject *swig_obj[1] ;
12933
12934 arg2 = &temp2;
12935 arg3 = &temp3;
12936 if (!args) SWIG_fail;
12937 swig_obj[0] = args;
12938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12939 if (!SWIG_IsOK(res1)) {
12940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12941 }
12942 arg1 = reinterpret_cast< wxGrid * >(argp1);
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 (arg1)->GetColLabelAlignment(arg2,arg3);
12946 wxPyEndAllowThreads(__tstate);
12947 if (PyErr_Occurred()) SWIG_fail;
12948 }
12949 resultobj = SWIG_Py_Void();
12950 if (SWIG_IsTmpObj(res2)) {
12951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12952 } else {
12953 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12955 }
12956 if (SWIG_IsTmpObj(res3)) {
12957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12958 } else {
12959 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12961 }
12962 return resultobj;
12963 fail:
12964 return NULL;
12965 }
12966
12967
12968 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12969 PyObject *resultobj = 0;
12970 wxGrid *arg1 = (wxGrid *) 0 ;
12971 int result;
12972 void *argp1 = 0 ;
12973 int res1 = 0 ;
12974 PyObject *swig_obj[1] ;
12975
12976 if (!args) SWIG_fail;
12977 swig_obj[0] = args;
12978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12979 if (!SWIG_IsOK(res1)) {
12980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12981 }
12982 arg1 = reinterpret_cast< wxGrid * >(argp1);
12983 {
12984 PyThreadState* __tstate = wxPyBeginAllowThreads();
12985 result = (int)(arg1)->GetColLabelTextOrientation();
12986 wxPyEndAllowThreads(__tstate);
12987 if (PyErr_Occurred()) SWIG_fail;
12988 }
12989 resultobj = SWIG_From_int(static_cast< int >(result));
12990 return resultobj;
12991 fail:
12992 return NULL;
12993 }
12994
12995
12996 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12997 PyObject *resultobj = 0;
12998 wxGrid *arg1 = (wxGrid *) 0 ;
12999 int arg2 ;
13000 wxString result;
13001 void *argp1 = 0 ;
13002 int res1 = 0 ;
13003 int val2 ;
13004 int ecode2 = 0 ;
13005 PyObject * obj0 = 0 ;
13006 PyObject * obj1 = 0 ;
13007 char * kwnames[] = {
13008 (char *) "self",(char *) "row", NULL
13009 };
13010
13011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13013 if (!SWIG_IsOK(res1)) {
13014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13015 }
13016 arg1 = reinterpret_cast< wxGrid * >(argp1);
13017 ecode2 = SWIG_AsVal_int(obj1, &val2);
13018 if (!SWIG_IsOK(ecode2)) {
13019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13020 }
13021 arg2 = static_cast< int >(val2);
13022 {
13023 PyThreadState* __tstate = wxPyBeginAllowThreads();
13024 result = (arg1)->GetRowLabelValue(arg2);
13025 wxPyEndAllowThreads(__tstate);
13026 if (PyErr_Occurred()) SWIG_fail;
13027 }
13028 {
13029 #if wxUSE_UNICODE
13030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13031 #else
13032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13033 #endif
13034 }
13035 return resultobj;
13036 fail:
13037 return NULL;
13038 }
13039
13040
13041 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13042 PyObject *resultobj = 0;
13043 wxGrid *arg1 = (wxGrid *) 0 ;
13044 int arg2 ;
13045 wxString result;
13046 void *argp1 = 0 ;
13047 int res1 = 0 ;
13048 int val2 ;
13049 int ecode2 = 0 ;
13050 PyObject * obj0 = 0 ;
13051 PyObject * obj1 = 0 ;
13052 char * kwnames[] = {
13053 (char *) "self",(char *) "col", NULL
13054 };
13055
13056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13058 if (!SWIG_IsOK(res1)) {
13059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13060 }
13061 arg1 = reinterpret_cast< wxGrid * >(argp1);
13062 ecode2 = SWIG_AsVal_int(obj1, &val2);
13063 if (!SWIG_IsOK(ecode2)) {
13064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13065 }
13066 arg2 = static_cast< int >(val2);
13067 {
13068 PyThreadState* __tstate = wxPyBeginAllowThreads();
13069 result = (arg1)->GetColLabelValue(arg2);
13070 wxPyEndAllowThreads(__tstate);
13071 if (PyErr_Occurred()) SWIG_fail;
13072 }
13073 {
13074 #if wxUSE_UNICODE
13075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13076 #else
13077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13078 #endif
13079 }
13080 return resultobj;
13081 fail:
13082 return NULL;
13083 }
13084
13085
13086 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13087 PyObject *resultobj = 0;
13088 wxGrid *arg1 = (wxGrid *) 0 ;
13089 wxColour result;
13090 void *argp1 = 0 ;
13091 int res1 = 0 ;
13092 PyObject *swig_obj[1] ;
13093
13094 if (!args) SWIG_fail;
13095 swig_obj[0] = args;
13096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13097 if (!SWIG_IsOK(res1)) {
13098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13099 }
13100 arg1 = reinterpret_cast< wxGrid * >(argp1);
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 result = (arg1)->GetGridLineColour();
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13115 PyObject *resultobj = 0;
13116 wxGrid *arg1 = (wxGrid *) 0 ;
13117 wxPen result;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 PyObject *swig_obj[1] ;
13121
13122 if (!args) SWIG_fail;
13123 swig_obj[0] = args;
13124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13127 }
13128 arg1 = reinterpret_cast< wxGrid * >(argp1);
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (arg1)->GetDefaultGridLinePen();
13132 wxPyEndAllowThreads(__tstate);
13133 if (PyErr_Occurred()) SWIG_fail;
13134 }
13135 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13136 return resultobj;
13137 fail:
13138 return NULL;
13139 }
13140
13141
13142 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13143 PyObject *resultobj = 0;
13144 wxGrid *arg1 = (wxGrid *) 0 ;
13145 int arg2 ;
13146 wxPen result;
13147 void *argp1 = 0 ;
13148 int res1 = 0 ;
13149 int val2 ;
13150 int ecode2 = 0 ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 char * kwnames[] = {
13154 (char *) "self",(char *) "row", NULL
13155 };
13156
13157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13159 if (!SWIG_IsOK(res1)) {
13160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13161 }
13162 arg1 = reinterpret_cast< wxGrid * >(argp1);
13163 ecode2 = SWIG_AsVal_int(obj1, &val2);
13164 if (!SWIG_IsOK(ecode2)) {
13165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13166 }
13167 arg2 = static_cast< int >(val2);
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 result = (arg1)->GetRowGridLinePen(arg2);
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13182 PyObject *resultobj = 0;
13183 wxGrid *arg1 = (wxGrid *) 0 ;
13184 int arg2 ;
13185 wxPen result;
13186 void *argp1 = 0 ;
13187 int res1 = 0 ;
13188 int val2 ;
13189 int ecode2 = 0 ;
13190 PyObject * obj0 = 0 ;
13191 PyObject * obj1 = 0 ;
13192 char * kwnames[] = {
13193 (char *) "self",(char *) "col", NULL
13194 };
13195
13196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13198 if (!SWIG_IsOK(res1)) {
13199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13200 }
13201 arg1 = reinterpret_cast< wxGrid * >(argp1);
13202 ecode2 = SWIG_AsVal_int(obj1, &val2);
13203 if (!SWIG_IsOK(ecode2)) {
13204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13205 }
13206 arg2 = static_cast< int >(val2);
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 result = (arg1)->GetColGridLinePen(arg2);
13210 wxPyEndAllowThreads(__tstate);
13211 if (PyErr_Occurred()) SWIG_fail;
13212 }
13213 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13214 return resultobj;
13215 fail:
13216 return NULL;
13217 }
13218
13219
13220 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13221 PyObject *resultobj = 0;
13222 wxGrid *arg1 = (wxGrid *) 0 ;
13223 wxColour result;
13224 void *argp1 = 0 ;
13225 int res1 = 0 ;
13226 PyObject *swig_obj[1] ;
13227
13228 if (!args) SWIG_fail;
13229 swig_obj[0] = args;
13230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13231 if (!SWIG_IsOK(res1)) {
13232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13233 }
13234 arg1 = reinterpret_cast< wxGrid * >(argp1);
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 result = (arg1)->GetCellHighlightColour();
13238 wxPyEndAllowThreads(__tstate);
13239 if (PyErr_Occurred()) SWIG_fail;
13240 }
13241 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13249 PyObject *resultobj = 0;
13250 wxGrid *arg1 = (wxGrid *) 0 ;
13251 int result;
13252 void *argp1 = 0 ;
13253 int res1 = 0 ;
13254 PyObject *swig_obj[1] ;
13255
13256 if (!args) SWIG_fail;
13257 swig_obj[0] = args;
13258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13259 if (!SWIG_IsOK(res1)) {
13260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13261 }
13262 arg1 = reinterpret_cast< wxGrid * >(argp1);
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 result = (int)(arg1)->GetCellHighlightPenWidth();
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 resultobj = SWIG_From_int(static_cast< int >(result));
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13277 PyObject *resultobj = 0;
13278 wxGrid *arg1 = (wxGrid *) 0 ;
13279 int result;
13280 void *argp1 = 0 ;
13281 int res1 = 0 ;
13282 PyObject *swig_obj[1] ;
13283
13284 if (!args) SWIG_fail;
13285 swig_obj[0] = args;
13286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13287 if (!SWIG_IsOK(res1)) {
13288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13289 }
13290 arg1 = reinterpret_cast< wxGrid * >(argp1);
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 result = (int)(arg1)->GetCellHighlightROPenWidth();
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 resultobj = SWIG_From_int(static_cast< int >(result));
13298 return resultobj;
13299 fail:
13300 return NULL;
13301 }
13302
13303
13304 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13305 PyObject *resultobj = 0;
13306 wxGrid *arg1 = (wxGrid *) 0 ;
13307 int arg2 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 int val2 ;
13311 int ecode2 = 0 ;
13312 PyObject * obj0 = 0 ;
13313 PyObject * obj1 = 0 ;
13314 char * kwnames[] = {
13315 (char *) "self",(char *) "width", NULL
13316 };
13317
13318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13320 if (!SWIG_IsOK(res1)) {
13321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13322 }
13323 arg1 = reinterpret_cast< wxGrid * >(argp1);
13324 ecode2 = SWIG_AsVal_int(obj1, &val2);
13325 if (!SWIG_IsOK(ecode2)) {
13326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13327 }
13328 arg2 = static_cast< int >(val2);
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 (arg1)->SetRowLabelSize(arg2);
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 resultobj = SWIG_Py_Void();
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13343 PyObject *resultobj = 0;
13344 wxGrid *arg1 = (wxGrid *) 0 ;
13345 int arg2 ;
13346 void *argp1 = 0 ;
13347 int res1 = 0 ;
13348 int val2 ;
13349 int ecode2 = 0 ;
13350 PyObject * obj0 = 0 ;
13351 PyObject * obj1 = 0 ;
13352 char * kwnames[] = {
13353 (char *) "self",(char *) "height", NULL
13354 };
13355
13356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13358 if (!SWIG_IsOK(res1)) {
13359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13360 }
13361 arg1 = reinterpret_cast< wxGrid * >(argp1);
13362 ecode2 = SWIG_AsVal_int(obj1, &val2);
13363 if (!SWIG_IsOK(ecode2)) {
13364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13365 }
13366 arg2 = static_cast< int >(val2);
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 (arg1)->SetColLabelSize(arg2);
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 resultobj = SWIG_Py_Void();
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13381 PyObject *resultobj = 0;
13382 wxGrid *arg1 = (wxGrid *) 0 ;
13383 wxColour *arg2 = 0 ;
13384 void *argp1 = 0 ;
13385 int res1 = 0 ;
13386 wxColour temp2 ;
13387 PyObject * obj0 = 0 ;
13388 PyObject * obj1 = 0 ;
13389 char * kwnames[] = {
13390 (char *) "self",(char *)"arg2", NULL
13391 };
13392
13393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13395 if (!SWIG_IsOK(res1)) {
13396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13397 }
13398 arg1 = reinterpret_cast< wxGrid * >(argp1);
13399 {
13400 arg2 = &temp2;
13401 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13402 }
13403 {
13404 PyThreadState* __tstate = wxPyBeginAllowThreads();
13405 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 resultobj = SWIG_Py_Void();
13410 return resultobj;
13411 fail:
13412 return NULL;
13413 }
13414
13415
13416 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13417 PyObject *resultobj = 0;
13418 wxGrid *arg1 = (wxGrid *) 0 ;
13419 wxColour *arg2 = 0 ;
13420 void *argp1 = 0 ;
13421 int res1 = 0 ;
13422 wxColour temp2 ;
13423 PyObject * obj0 = 0 ;
13424 PyObject * obj1 = 0 ;
13425 char * kwnames[] = {
13426 (char *) "self",(char *)"arg2", NULL
13427 };
13428
13429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13431 if (!SWIG_IsOK(res1)) {
13432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13433 }
13434 arg1 = reinterpret_cast< wxGrid * >(argp1);
13435 {
13436 arg2 = &temp2;
13437 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13438 }
13439 {
13440 PyThreadState* __tstate = wxPyBeginAllowThreads();
13441 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 resultobj = SWIG_Py_Void();
13446 return resultobj;
13447 fail:
13448 return NULL;
13449 }
13450
13451
13452 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj = 0;
13454 wxGrid *arg1 = (wxGrid *) 0 ;
13455 wxFont *arg2 = 0 ;
13456 void *argp1 = 0 ;
13457 int res1 = 0 ;
13458 void *argp2 = 0 ;
13459 int res2 = 0 ;
13460 PyObject * obj0 = 0 ;
13461 PyObject * obj1 = 0 ;
13462 char * kwnames[] = {
13463 (char *) "self",(char *)"arg2", NULL
13464 };
13465
13466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13468 if (!SWIG_IsOK(res1)) {
13469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13470 }
13471 arg1 = reinterpret_cast< wxGrid * >(argp1);
13472 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13473 if (!SWIG_IsOK(res2)) {
13474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13475 }
13476 if (!argp2) {
13477 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13478 }
13479 arg2 = reinterpret_cast< wxFont * >(argp2);
13480 {
13481 PyThreadState* __tstate = wxPyBeginAllowThreads();
13482 (arg1)->SetLabelFont((wxFont const &)*arg2);
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 resultobj = SWIG_Py_Void();
13487 return resultobj;
13488 fail:
13489 return NULL;
13490 }
13491
13492
13493 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj = 0;
13495 wxGrid *arg1 = (wxGrid *) 0 ;
13496 int arg2 ;
13497 int arg3 ;
13498 void *argp1 = 0 ;
13499 int res1 = 0 ;
13500 int val2 ;
13501 int ecode2 = 0 ;
13502 int val3 ;
13503 int ecode3 = 0 ;
13504 PyObject * obj0 = 0 ;
13505 PyObject * obj1 = 0 ;
13506 PyObject * obj2 = 0 ;
13507 char * kwnames[] = {
13508 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13509 };
13510
13511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13513 if (!SWIG_IsOK(res1)) {
13514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13515 }
13516 arg1 = reinterpret_cast< wxGrid * >(argp1);
13517 ecode2 = SWIG_AsVal_int(obj1, &val2);
13518 if (!SWIG_IsOK(ecode2)) {
13519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13520 }
13521 arg2 = static_cast< int >(val2);
13522 ecode3 = SWIG_AsVal_int(obj2, &val3);
13523 if (!SWIG_IsOK(ecode3)) {
13524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13525 }
13526 arg3 = static_cast< int >(val3);
13527 {
13528 PyThreadState* __tstate = wxPyBeginAllowThreads();
13529 (arg1)->SetRowLabelAlignment(arg2,arg3);
13530 wxPyEndAllowThreads(__tstate);
13531 if (PyErr_Occurred()) SWIG_fail;
13532 }
13533 resultobj = SWIG_Py_Void();
13534 return resultobj;
13535 fail:
13536 return NULL;
13537 }
13538
13539
13540 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13541 PyObject *resultobj = 0;
13542 wxGrid *arg1 = (wxGrid *) 0 ;
13543 int arg2 ;
13544 int arg3 ;
13545 void *argp1 = 0 ;
13546 int res1 = 0 ;
13547 int val2 ;
13548 int ecode2 = 0 ;
13549 int val3 ;
13550 int ecode3 = 0 ;
13551 PyObject * obj0 = 0 ;
13552 PyObject * obj1 = 0 ;
13553 PyObject * obj2 = 0 ;
13554 char * kwnames[] = {
13555 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13556 };
13557
13558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13560 if (!SWIG_IsOK(res1)) {
13561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13562 }
13563 arg1 = reinterpret_cast< wxGrid * >(argp1);
13564 ecode2 = SWIG_AsVal_int(obj1, &val2);
13565 if (!SWIG_IsOK(ecode2)) {
13566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13567 }
13568 arg2 = static_cast< int >(val2);
13569 ecode3 = SWIG_AsVal_int(obj2, &val3);
13570 if (!SWIG_IsOK(ecode3)) {
13571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13572 }
13573 arg3 = static_cast< int >(val3);
13574 {
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 (arg1)->SetColLabelAlignment(arg2,arg3);
13577 wxPyEndAllowThreads(__tstate);
13578 if (PyErr_Occurred()) SWIG_fail;
13579 }
13580 resultobj = SWIG_Py_Void();
13581 return resultobj;
13582 fail:
13583 return NULL;
13584 }
13585
13586
13587 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13588 PyObject *resultobj = 0;
13589 wxGrid *arg1 = (wxGrid *) 0 ;
13590 int arg2 ;
13591 void *argp1 = 0 ;
13592 int res1 = 0 ;
13593 int val2 ;
13594 int ecode2 = 0 ;
13595 PyObject * obj0 = 0 ;
13596 PyObject * obj1 = 0 ;
13597 char * kwnames[] = {
13598 (char *) "self",(char *) "textOrientation", NULL
13599 };
13600
13601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13603 if (!SWIG_IsOK(res1)) {
13604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13605 }
13606 arg1 = reinterpret_cast< wxGrid * >(argp1);
13607 ecode2 = SWIG_AsVal_int(obj1, &val2);
13608 if (!SWIG_IsOK(ecode2)) {
13609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13610 }
13611 arg2 = static_cast< int >(val2);
13612 {
13613 PyThreadState* __tstate = wxPyBeginAllowThreads();
13614 (arg1)->SetColLabelTextOrientation(arg2);
13615 wxPyEndAllowThreads(__tstate);
13616 if (PyErr_Occurred()) SWIG_fail;
13617 }
13618 resultobj = SWIG_Py_Void();
13619 return resultobj;
13620 fail:
13621 return NULL;
13622 }
13623
13624
13625 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj = 0;
13627 wxGrid *arg1 = (wxGrid *) 0 ;
13628 int arg2 ;
13629 wxString *arg3 = 0 ;
13630 void *argp1 = 0 ;
13631 int res1 = 0 ;
13632 int val2 ;
13633 int ecode2 = 0 ;
13634 bool temp3 = false ;
13635 PyObject * obj0 = 0 ;
13636 PyObject * obj1 = 0 ;
13637 PyObject * obj2 = 0 ;
13638 char * kwnames[] = {
13639 (char *) "self",(char *) "row",(char *)"arg3", NULL
13640 };
13641
13642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13644 if (!SWIG_IsOK(res1)) {
13645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13646 }
13647 arg1 = reinterpret_cast< wxGrid * >(argp1);
13648 ecode2 = SWIG_AsVal_int(obj1, &val2);
13649 if (!SWIG_IsOK(ecode2)) {
13650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13651 }
13652 arg2 = static_cast< int >(val2);
13653 {
13654 arg3 = wxString_in_helper(obj2);
13655 if (arg3 == NULL) SWIG_fail;
13656 temp3 = true;
13657 }
13658 {
13659 PyThreadState* __tstate = wxPyBeginAllowThreads();
13660 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13661 wxPyEndAllowThreads(__tstate);
13662 if (PyErr_Occurred()) SWIG_fail;
13663 }
13664 resultobj = SWIG_Py_Void();
13665 {
13666 if (temp3)
13667 delete arg3;
13668 }
13669 return resultobj;
13670 fail:
13671 {
13672 if (temp3)
13673 delete arg3;
13674 }
13675 return NULL;
13676 }
13677
13678
13679 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13680 PyObject *resultobj = 0;
13681 wxGrid *arg1 = (wxGrid *) 0 ;
13682 int arg2 ;
13683 wxString *arg3 = 0 ;
13684 void *argp1 = 0 ;
13685 int res1 = 0 ;
13686 int val2 ;
13687 int ecode2 = 0 ;
13688 bool temp3 = false ;
13689 PyObject * obj0 = 0 ;
13690 PyObject * obj1 = 0 ;
13691 PyObject * obj2 = 0 ;
13692 char * kwnames[] = {
13693 (char *) "self",(char *) "col",(char *)"arg3", NULL
13694 };
13695
13696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13698 if (!SWIG_IsOK(res1)) {
13699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13700 }
13701 arg1 = reinterpret_cast< wxGrid * >(argp1);
13702 ecode2 = SWIG_AsVal_int(obj1, &val2);
13703 if (!SWIG_IsOK(ecode2)) {
13704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13705 }
13706 arg2 = static_cast< int >(val2);
13707 {
13708 arg3 = wxString_in_helper(obj2);
13709 if (arg3 == NULL) SWIG_fail;
13710 temp3 = true;
13711 }
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13715 wxPyEndAllowThreads(__tstate);
13716 if (PyErr_Occurred()) SWIG_fail;
13717 }
13718 resultobj = SWIG_Py_Void();
13719 {
13720 if (temp3)
13721 delete arg3;
13722 }
13723 return resultobj;
13724 fail:
13725 {
13726 if (temp3)
13727 delete arg3;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj = 0;
13735 wxGrid *arg1 = (wxGrid *) 0 ;
13736 wxColour *arg2 = 0 ;
13737 void *argp1 = 0 ;
13738 int res1 = 0 ;
13739 wxColour temp2 ;
13740 PyObject * obj0 = 0 ;
13741 PyObject * obj1 = 0 ;
13742 char * kwnames[] = {
13743 (char *) "self",(char *)"arg2", NULL
13744 };
13745
13746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
13747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13748 if (!SWIG_IsOK(res1)) {
13749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13750 }
13751 arg1 = reinterpret_cast< wxGrid * >(argp1);
13752 {
13753 arg2 = &temp2;
13754 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13755 }
13756 {
13757 PyThreadState* __tstate = wxPyBeginAllowThreads();
13758 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13759 wxPyEndAllowThreads(__tstate);
13760 if (PyErr_Occurred()) SWIG_fail;
13761 }
13762 resultobj = SWIG_Py_Void();
13763 return resultobj;
13764 fail:
13765 return NULL;
13766 }
13767
13768
13769 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj = 0;
13771 wxGrid *arg1 = (wxGrid *) 0 ;
13772 wxColour *arg2 = 0 ;
13773 void *argp1 = 0 ;
13774 int res1 = 0 ;
13775 wxColour temp2 ;
13776 PyObject * obj0 = 0 ;
13777 PyObject * obj1 = 0 ;
13778 char * kwnames[] = {
13779 (char *) "self",(char *)"arg2", NULL
13780 };
13781
13782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13784 if (!SWIG_IsOK(res1)) {
13785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13786 }
13787 arg1 = reinterpret_cast< wxGrid * >(argp1);
13788 {
13789 arg2 = &temp2;
13790 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13791 }
13792 {
13793 PyThreadState* __tstate = wxPyBeginAllowThreads();
13794 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13795 wxPyEndAllowThreads(__tstate);
13796 if (PyErr_Occurred()) SWIG_fail;
13797 }
13798 resultobj = SWIG_Py_Void();
13799 return resultobj;
13800 fail:
13801 return NULL;
13802 }
13803
13804
13805 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13806 PyObject *resultobj = 0;
13807 wxGrid *arg1 = (wxGrid *) 0 ;
13808 int arg2 ;
13809 void *argp1 = 0 ;
13810 int res1 = 0 ;
13811 int val2 ;
13812 int ecode2 = 0 ;
13813 PyObject * obj0 = 0 ;
13814 PyObject * obj1 = 0 ;
13815 char * kwnames[] = {
13816 (char *) "self",(char *) "width", NULL
13817 };
13818
13819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13821 if (!SWIG_IsOK(res1)) {
13822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13823 }
13824 arg1 = reinterpret_cast< wxGrid * >(argp1);
13825 ecode2 = SWIG_AsVal_int(obj1, &val2);
13826 if (!SWIG_IsOK(ecode2)) {
13827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13828 }
13829 arg2 = static_cast< int >(val2);
13830 {
13831 PyThreadState* __tstate = wxPyBeginAllowThreads();
13832 (arg1)->SetCellHighlightPenWidth(arg2);
13833 wxPyEndAllowThreads(__tstate);
13834 if (PyErr_Occurred()) SWIG_fail;
13835 }
13836 resultobj = SWIG_Py_Void();
13837 return resultobj;
13838 fail:
13839 return NULL;
13840 }
13841
13842
13843 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13844 PyObject *resultobj = 0;
13845 wxGrid *arg1 = (wxGrid *) 0 ;
13846 int arg2 ;
13847 void *argp1 = 0 ;
13848 int res1 = 0 ;
13849 int val2 ;
13850 int ecode2 = 0 ;
13851 PyObject * obj0 = 0 ;
13852 PyObject * obj1 = 0 ;
13853 char * kwnames[] = {
13854 (char *) "self",(char *) "width", NULL
13855 };
13856
13857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13859 if (!SWIG_IsOK(res1)) {
13860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13861 }
13862 arg1 = reinterpret_cast< wxGrid * >(argp1);
13863 ecode2 = SWIG_AsVal_int(obj1, &val2);
13864 if (!SWIG_IsOK(ecode2)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13866 }
13867 arg2 = static_cast< int >(val2);
13868 {
13869 PyThreadState* __tstate = wxPyBeginAllowThreads();
13870 (arg1)->SetCellHighlightROPenWidth(arg2);
13871 wxPyEndAllowThreads(__tstate);
13872 if (PyErr_Occurred()) SWIG_fail;
13873 }
13874 resultobj = SWIG_Py_Void();
13875 return resultobj;
13876 fail:
13877 return NULL;
13878 }
13879
13880
13881 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13882 PyObject *resultobj = 0;
13883 wxGrid *arg1 = (wxGrid *) 0 ;
13884 bool arg2 = (bool) true ;
13885 void *argp1 = 0 ;
13886 int res1 = 0 ;
13887 bool val2 ;
13888 int ecode2 = 0 ;
13889 PyObject * obj0 = 0 ;
13890 PyObject * obj1 = 0 ;
13891 char * kwnames[] = {
13892 (char *) "self",(char *) "enable", NULL
13893 };
13894
13895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13897 if (!SWIG_IsOK(res1)) {
13898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13899 }
13900 arg1 = reinterpret_cast< wxGrid * >(argp1);
13901 if (obj1) {
13902 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13903 if (!SWIG_IsOK(ecode2)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13905 }
13906 arg2 = static_cast< bool >(val2);
13907 }
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 (arg1)->EnableDragRowSize(arg2);
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_Py_Void();
13915 return resultobj;
13916 fail:
13917 return NULL;
13918 }
13919
13920
13921 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13922 PyObject *resultobj = 0;
13923 wxGrid *arg1 = (wxGrid *) 0 ;
13924 void *argp1 = 0 ;
13925 int res1 = 0 ;
13926 PyObject *swig_obj[1] ;
13927
13928 if (!args) SWIG_fail;
13929 swig_obj[0] = args;
13930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13931 if (!SWIG_IsOK(res1)) {
13932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13933 }
13934 arg1 = reinterpret_cast< wxGrid * >(argp1);
13935 {
13936 PyThreadState* __tstate = wxPyBeginAllowThreads();
13937 (arg1)->DisableDragRowSize();
13938 wxPyEndAllowThreads(__tstate);
13939 if (PyErr_Occurred()) SWIG_fail;
13940 }
13941 resultobj = SWIG_Py_Void();
13942 return resultobj;
13943 fail:
13944 return NULL;
13945 }
13946
13947
13948 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13949 PyObject *resultobj = 0;
13950 wxGrid *arg1 = (wxGrid *) 0 ;
13951 bool result;
13952 void *argp1 = 0 ;
13953 int res1 = 0 ;
13954 PyObject *swig_obj[1] ;
13955
13956 if (!args) SWIG_fail;
13957 swig_obj[0] = args;
13958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13959 if (!SWIG_IsOK(res1)) {
13960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13961 }
13962 arg1 = reinterpret_cast< wxGrid * >(argp1);
13963 {
13964 PyThreadState* __tstate = wxPyBeginAllowThreads();
13965 result = (bool)(arg1)->CanDragRowSize();
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 {
13970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13971 }
13972 return resultobj;
13973 fail:
13974 return NULL;
13975 }
13976
13977
13978 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj = 0;
13980 wxGrid *arg1 = (wxGrid *) 0 ;
13981 bool arg2 = (bool) true ;
13982 void *argp1 = 0 ;
13983 int res1 = 0 ;
13984 bool val2 ;
13985 int ecode2 = 0 ;
13986 PyObject * obj0 = 0 ;
13987 PyObject * obj1 = 0 ;
13988 char * kwnames[] = {
13989 (char *) "self",(char *) "enable", NULL
13990 };
13991
13992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13994 if (!SWIG_IsOK(res1)) {
13995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13996 }
13997 arg1 = reinterpret_cast< wxGrid * >(argp1);
13998 if (obj1) {
13999 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14000 if (!SWIG_IsOK(ecode2)) {
14001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14002 }
14003 arg2 = static_cast< bool >(val2);
14004 }
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 (arg1)->EnableDragColSize(arg2);
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_Py_Void();
14012 return resultobj;
14013 fail:
14014 return NULL;
14015 }
14016
14017
14018 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14019 PyObject *resultobj = 0;
14020 wxGrid *arg1 = (wxGrid *) 0 ;
14021 void *argp1 = 0 ;
14022 int res1 = 0 ;
14023 PyObject *swig_obj[1] ;
14024
14025 if (!args) SWIG_fail;
14026 swig_obj[0] = args;
14027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14028 if (!SWIG_IsOK(res1)) {
14029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14030 }
14031 arg1 = reinterpret_cast< wxGrid * >(argp1);
14032 {
14033 PyThreadState* __tstate = wxPyBeginAllowThreads();
14034 (arg1)->DisableDragColSize();
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 resultobj = SWIG_Py_Void();
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14046 PyObject *resultobj = 0;
14047 wxGrid *arg1 = (wxGrid *) 0 ;
14048 bool result;
14049 void *argp1 = 0 ;
14050 int res1 = 0 ;
14051 PyObject *swig_obj[1] ;
14052
14053 if (!args) SWIG_fail;
14054 swig_obj[0] = args;
14055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14056 if (!SWIG_IsOK(res1)) {
14057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14058 }
14059 arg1 = reinterpret_cast< wxGrid * >(argp1);
14060 {
14061 PyThreadState* __tstate = wxPyBeginAllowThreads();
14062 result = (bool)(arg1)->CanDragColSize();
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 {
14067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14068 }
14069 return resultobj;
14070 fail:
14071 return NULL;
14072 }
14073
14074
14075 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14076 PyObject *resultobj = 0;
14077 wxGrid *arg1 = (wxGrid *) 0 ;
14078 bool arg2 = (bool) true ;
14079 void *argp1 = 0 ;
14080 int res1 = 0 ;
14081 bool val2 ;
14082 int ecode2 = 0 ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 char * kwnames[] = {
14086 (char *) "self",(char *) "enable", NULL
14087 };
14088
14089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14091 if (!SWIG_IsOK(res1)) {
14092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14093 }
14094 arg1 = reinterpret_cast< wxGrid * >(argp1);
14095 if (obj1) {
14096 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14097 if (!SWIG_IsOK(ecode2)) {
14098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14099 }
14100 arg2 = static_cast< bool >(val2);
14101 }
14102 {
14103 PyThreadState* __tstate = wxPyBeginAllowThreads();
14104 (arg1)->EnableDragColMove(arg2);
14105 wxPyEndAllowThreads(__tstate);
14106 if (PyErr_Occurred()) SWIG_fail;
14107 }
14108 resultobj = SWIG_Py_Void();
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14116 PyObject *resultobj = 0;
14117 wxGrid *arg1 = (wxGrid *) 0 ;
14118 void *argp1 = 0 ;
14119 int res1 = 0 ;
14120 PyObject *swig_obj[1] ;
14121
14122 if (!args) SWIG_fail;
14123 swig_obj[0] = args;
14124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14125 if (!SWIG_IsOK(res1)) {
14126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14127 }
14128 arg1 = reinterpret_cast< wxGrid * >(argp1);
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 (arg1)->DisableDragColMove();
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 resultobj = SWIG_Py_Void();
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14143 PyObject *resultobj = 0;
14144 wxGrid *arg1 = (wxGrid *) 0 ;
14145 bool result;
14146 void *argp1 = 0 ;
14147 int res1 = 0 ;
14148 PyObject *swig_obj[1] ;
14149
14150 if (!args) SWIG_fail;
14151 swig_obj[0] = args;
14152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14153 if (!SWIG_IsOK(res1)) {
14154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14155 }
14156 arg1 = reinterpret_cast< wxGrid * >(argp1);
14157 {
14158 PyThreadState* __tstate = wxPyBeginAllowThreads();
14159 result = (bool)(arg1)->CanDragColMove();
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 {
14164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14165 }
14166 return resultobj;
14167 fail:
14168 return NULL;
14169 }
14170
14171
14172 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14173 PyObject *resultobj = 0;
14174 wxGrid *arg1 = (wxGrid *) 0 ;
14175 bool arg2 = (bool) true ;
14176 void *argp1 = 0 ;
14177 int res1 = 0 ;
14178 bool val2 ;
14179 int ecode2 = 0 ;
14180 PyObject * obj0 = 0 ;
14181 PyObject * obj1 = 0 ;
14182 char * kwnames[] = {
14183 (char *) "self",(char *) "enable", NULL
14184 };
14185
14186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14188 if (!SWIG_IsOK(res1)) {
14189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14190 }
14191 arg1 = reinterpret_cast< wxGrid * >(argp1);
14192 if (obj1) {
14193 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14194 if (!SWIG_IsOK(ecode2)) {
14195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14196 }
14197 arg2 = static_cast< bool >(val2);
14198 }
14199 {
14200 PyThreadState* __tstate = wxPyBeginAllowThreads();
14201 (arg1)->EnableDragGridSize(arg2);
14202 wxPyEndAllowThreads(__tstate);
14203 if (PyErr_Occurred()) SWIG_fail;
14204 }
14205 resultobj = SWIG_Py_Void();
14206 return resultobj;
14207 fail:
14208 return NULL;
14209 }
14210
14211
14212 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14213 PyObject *resultobj = 0;
14214 wxGrid *arg1 = (wxGrid *) 0 ;
14215 void *argp1 = 0 ;
14216 int res1 = 0 ;
14217 PyObject *swig_obj[1] ;
14218
14219 if (!args) SWIG_fail;
14220 swig_obj[0] = args;
14221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14222 if (!SWIG_IsOK(res1)) {
14223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14224 }
14225 arg1 = reinterpret_cast< wxGrid * >(argp1);
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 (arg1)->DisableDragGridSize();
14229 wxPyEndAllowThreads(__tstate);
14230 if (PyErr_Occurred()) SWIG_fail;
14231 }
14232 resultobj = SWIG_Py_Void();
14233 return resultobj;
14234 fail:
14235 return NULL;
14236 }
14237
14238
14239 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14240 PyObject *resultobj = 0;
14241 wxGrid *arg1 = (wxGrid *) 0 ;
14242 bool result;
14243 void *argp1 = 0 ;
14244 int res1 = 0 ;
14245 PyObject *swig_obj[1] ;
14246
14247 if (!args) SWIG_fail;
14248 swig_obj[0] = args;
14249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14250 if (!SWIG_IsOK(res1)) {
14251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14252 }
14253 arg1 = reinterpret_cast< wxGrid * >(argp1);
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (bool)(arg1)->CanDragGridSize();
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 {
14261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14262 }
14263 return resultobj;
14264 fail:
14265 return NULL;
14266 }
14267
14268
14269 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14270 PyObject *resultobj = 0;
14271 wxGrid *arg1 = (wxGrid *) 0 ;
14272 bool arg2 = (bool) true ;
14273 void *argp1 = 0 ;
14274 int res1 = 0 ;
14275 bool val2 ;
14276 int ecode2 = 0 ;
14277 PyObject * obj0 = 0 ;
14278 PyObject * obj1 = 0 ;
14279 char * kwnames[] = {
14280 (char *) "self",(char *) "enable", NULL
14281 };
14282
14283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14285 if (!SWIG_IsOK(res1)) {
14286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14287 }
14288 arg1 = reinterpret_cast< wxGrid * >(argp1);
14289 if (obj1) {
14290 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14291 if (!SWIG_IsOK(ecode2)) {
14292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14293 }
14294 arg2 = static_cast< bool >(val2);
14295 }
14296 {
14297 PyThreadState* __tstate = wxPyBeginAllowThreads();
14298 (arg1)->EnableDragCell(arg2);
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 resultobj = SWIG_Py_Void();
14303 return resultobj;
14304 fail:
14305 return NULL;
14306 }
14307
14308
14309 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14310 PyObject *resultobj = 0;
14311 wxGrid *arg1 = (wxGrid *) 0 ;
14312 void *argp1 = 0 ;
14313 int res1 = 0 ;
14314 PyObject *swig_obj[1] ;
14315
14316 if (!args) SWIG_fail;
14317 swig_obj[0] = args;
14318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14319 if (!SWIG_IsOK(res1)) {
14320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14321 }
14322 arg1 = reinterpret_cast< wxGrid * >(argp1);
14323 {
14324 PyThreadState* __tstate = wxPyBeginAllowThreads();
14325 (arg1)->DisableDragCell();
14326 wxPyEndAllowThreads(__tstate);
14327 if (PyErr_Occurred()) SWIG_fail;
14328 }
14329 resultobj = SWIG_Py_Void();
14330 return resultobj;
14331 fail:
14332 return NULL;
14333 }
14334
14335
14336 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14337 PyObject *resultobj = 0;
14338 wxGrid *arg1 = (wxGrid *) 0 ;
14339 bool result;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 PyObject *swig_obj[1] ;
14343
14344 if (!args) SWIG_fail;
14345 swig_obj[0] = args;
14346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14347 if (!SWIG_IsOK(res1)) {
14348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14349 }
14350 arg1 = reinterpret_cast< wxGrid * >(argp1);
14351 {
14352 PyThreadState* __tstate = wxPyBeginAllowThreads();
14353 result = (bool)(arg1)->CanDragCell();
14354 wxPyEndAllowThreads(__tstate);
14355 if (PyErr_Occurred()) SWIG_fail;
14356 }
14357 {
14358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14359 }
14360 return resultobj;
14361 fail:
14362 return NULL;
14363 }
14364
14365
14366 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14367 PyObject *resultobj = 0;
14368 wxGrid *arg1 = (wxGrid *) 0 ;
14369 int arg2 ;
14370 int arg3 ;
14371 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14372 void *argp1 = 0 ;
14373 int res1 = 0 ;
14374 int val2 ;
14375 int ecode2 = 0 ;
14376 int val3 ;
14377 int ecode3 = 0 ;
14378 void *argp4 = 0 ;
14379 int res4 = 0 ;
14380 PyObject * obj0 = 0 ;
14381 PyObject * obj1 = 0 ;
14382 PyObject * obj2 = 0 ;
14383 PyObject * obj3 = 0 ;
14384 char * kwnames[] = {
14385 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14386 };
14387
14388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14390 if (!SWIG_IsOK(res1)) {
14391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14392 }
14393 arg1 = reinterpret_cast< wxGrid * >(argp1);
14394 ecode2 = SWIG_AsVal_int(obj1, &val2);
14395 if (!SWIG_IsOK(ecode2)) {
14396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14397 }
14398 arg2 = static_cast< int >(val2);
14399 ecode3 = SWIG_AsVal_int(obj2, &val3);
14400 if (!SWIG_IsOK(ecode3)) {
14401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14402 }
14403 arg3 = static_cast< int >(val3);
14404 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14405 if (!SWIG_IsOK(res4)) {
14406 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14407 }
14408 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 (arg1)->SetAttr(arg2,arg3,arg4);
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 resultobj = SWIG_Py_Void();
14416 return resultobj;
14417 fail:
14418 return NULL;
14419 }
14420
14421
14422 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14423 PyObject *resultobj = 0;
14424 wxGrid *arg1 = (wxGrid *) 0 ;
14425 int arg2 ;
14426 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14427 void *argp1 = 0 ;
14428 int res1 = 0 ;
14429 int val2 ;
14430 int ecode2 = 0 ;
14431 void *argp3 = 0 ;
14432 int res3 = 0 ;
14433 PyObject * obj0 = 0 ;
14434 PyObject * obj1 = 0 ;
14435 PyObject * obj2 = 0 ;
14436 char * kwnames[] = {
14437 (char *) "self",(char *) "row",(char *) "attr", NULL
14438 };
14439
14440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14442 if (!SWIG_IsOK(res1)) {
14443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14444 }
14445 arg1 = reinterpret_cast< wxGrid * >(argp1);
14446 ecode2 = SWIG_AsVal_int(obj1, &val2);
14447 if (!SWIG_IsOK(ecode2)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14449 }
14450 arg2 = static_cast< int >(val2);
14451 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14452 if (!SWIG_IsOK(res3)) {
14453 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14454 }
14455 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14456 {
14457 PyThreadState* __tstate = wxPyBeginAllowThreads();
14458 (arg1)->SetRowAttr(arg2,arg3);
14459 wxPyEndAllowThreads(__tstate);
14460 if (PyErr_Occurred()) SWIG_fail;
14461 }
14462 resultobj = SWIG_Py_Void();
14463 return resultobj;
14464 fail:
14465 return NULL;
14466 }
14467
14468
14469 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14470 PyObject *resultobj = 0;
14471 wxGrid *arg1 = (wxGrid *) 0 ;
14472 int arg2 ;
14473 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14474 void *argp1 = 0 ;
14475 int res1 = 0 ;
14476 int val2 ;
14477 int ecode2 = 0 ;
14478 void *argp3 = 0 ;
14479 int res3 = 0 ;
14480 PyObject * obj0 = 0 ;
14481 PyObject * obj1 = 0 ;
14482 PyObject * obj2 = 0 ;
14483 char * kwnames[] = {
14484 (char *) "self",(char *) "col",(char *) "attr", NULL
14485 };
14486
14487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14489 if (!SWIG_IsOK(res1)) {
14490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14491 }
14492 arg1 = reinterpret_cast< wxGrid * >(argp1);
14493 ecode2 = SWIG_AsVal_int(obj1, &val2);
14494 if (!SWIG_IsOK(ecode2)) {
14495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14496 }
14497 arg2 = static_cast< int >(val2);
14498 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14499 if (!SWIG_IsOK(res3)) {
14500 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14501 }
14502 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14503 {
14504 PyThreadState* __tstate = wxPyBeginAllowThreads();
14505 (arg1)->SetColAttr(arg2,arg3);
14506 wxPyEndAllowThreads(__tstate);
14507 if (PyErr_Occurred()) SWIG_fail;
14508 }
14509 resultobj = SWIG_Py_Void();
14510 return resultobj;
14511 fail:
14512 return NULL;
14513 }
14514
14515
14516 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14517 PyObject *resultobj = 0;
14518 wxGrid *arg1 = (wxGrid *) 0 ;
14519 int arg2 ;
14520 int arg3 ;
14521 wxGridCellAttr *result = 0 ;
14522 void *argp1 = 0 ;
14523 int res1 = 0 ;
14524 int val2 ;
14525 int ecode2 = 0 ;
14526 int val3 ;
14527 int ecode3 = 0 ;
14528 PyObject * obj0 = 0 ;
14529 PyObject * obj1 = 0 ;
14530 PyObject * obj2 = 0 ;
14531 char * kwnames[] = {
14532 (char *) "self",(char *) "row",(char *) "col", NULL
14533 };
14534
14535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14537 if (!SWIG_IsOK(res1)) {
14538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14539 }
14540 arg1 = reinterpret_cast< wxGrid * >(argp1);
14541 ecode2 = SWIG_AsVal_int(obj1, &val2);
14542 if (!SWIG_IsOK(ecode2)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14544 }
14545 arg2 = static_cast< int >(val2);
14546 ecode3 = SWIG_AsVal_int(obj2, &val3);
14547 if (!SWIG_IsOK(ecode3)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14549 }
14550 arg3 = static_cast< int >(val3);
14551 {
14552 PyThreadState* __tstate = wxPyBeginAllowThreads();
14553 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14554 wxPyEndAllowThreads(__tstate);
14555 if (PyErr_Occurred()) SWIG_fail;
14556 }
14557 {
14558 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14559 }
14560 return resultobj;
14561 fail:
14562 return NULL;
14563 }
14564
14565
14566 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj = 0;
14568 wxGrid *arg1 = (wxGrid *) 0 ;
14569 int arg2 ;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 int val2 ;
14573 int ecode2 = 0 ;
14574 PyObject * obj0 = 0 ;
14575 PyObject * obj1 = 0 ;
14576 char * kwnames[] = {
14577 (char *) "self",(char *) "col", NULL
14578 };
14579
14580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14582 if (!SWIG_IsOK(res1)) {
14583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14584 }
14585 arg1 = reinterpret_cast< wxGrid * >(argp1);
14586 ecode2 = SWIG_AsVal_int(obj1, &val2);
14587 if (!SWIG_IsOK(ecode2)) {
14588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14589 }
14590 arg2 = static_cast< int >(val2);
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 (arg1)->SetColFormatBool(arg2);
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 resultobj = SWIG_Py_Void();
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14605 PyObject *resultobj = 0;
14606 wxGrid *arg1 = (wxGrid *) 0 ;
14607 int arg2 ;
14608 void *argp1 = 0 ;
14609 int res1 = 0 ;
14610 int val2 ;
14611 int ecode2 = 0 ;
14612 PyObject * obj0 = 0 ;
14613 PyObject * obj1 = 0 ;
14614 char * kwnames[] = {
14615 (char *) "self",(char *) "col", NULL
14616 };
14617
14618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14620 if (!SWIG_IsOK(res1)) {
14621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14622 }
14623 arg1 = reinterpret_cast< wxGrid * >(argp1);
14624 ecode2 = SWIG_AsVal_int(obj1, &val2);
14625 if (!SWIG_IsOK(ecode2)) {
14626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14627 }
14628 arg2 = static_cast< int >(val2);
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 (arg1)->SetColFormatNumber(arg2);
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_Py_Void();
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj = 0;
14644 wxGrid *arg1 = (wxGrid *) 0 ;
14645 int arg2 ;
14646 int arg3 = (int) -1 ;
14647 int arg4 = (int) -1 ;
14648 void *argp1 = 0 ;
14649 int res1 = 0 ;
14650 int val2 ;
14651 int ecode2 = 0 ;
14652 int val3 ;
14653 int ecode3 = 0 ;
14654 int val4 ;
14655 int ecode4 = 0 ;
14656 PyObject * obj0 = 0 ;
14657 PyObject * obj1 = 0 ;
14658 PyObject * obj2 = 0 ;
14659 PyObject * obj3 = 0 ;
14660 char * kwnames[] = {
14661 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14662 };
14663
14664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14666 if (!SWIG_IsOK(res1)) {
14667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14668 }
14669 arg1 = reinterpret_cast< wxGrid * >(argp1);
14670 ecode2 = SWIG_AsVal_int(obj1, &val2);
14671 if (!SWIG_IsOK(ecode2)) {
14672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14673 }
14674 arg2 = static_cast< int >(val2);
14675 if (obj2) {
14676 ecode3 = SWIG_AsVal_int(obj2, &val3);
14677 if (!SWIG_IsOK(ecode3)) {
14678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14679 }
14680 arg3 = static_cast< int >(val3);
14681 }
14682 if (obj3) {
14683 ecode4 = SWIG_AsVal_int(obj3, &val4);
14684 if (!SWIG_IsOK(ecode4)) {
14685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14686 }
14687 arg4 = static_cast< int >(val4);
14688 }
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 resultobj = SWIG_Py_Void();
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14703 PyObject *resultobj = 0;
14704 wxGrid *arg1 = (wxGrid *) 0 ;
14705 int arg2 ;
14706 wxString *arg3 = 0 ;
14707 void *argp1 = 0 ;
14708 int res1 = 0 ;
14709 int val2 ;
14710 int ecode2 = 0 ;
14711 bool temp3 = false ;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 PyObject * obj2 = 0 ;
14715 char * kwnames[] = {
14716 (char *) "self",(char *) "col",(char *) "typeName", NULL
14717 };
14718
14719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14721 if (!SWIG_IsOK(res1)) {
14722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14723 }
14724 arg1 = reinterpret_cast< wxGrid * >(argp1);
14725 ecode2 = SWIG_AsVal_int(obj1, &val2);
14726 if (!SWIG_IsOK(ecode2)) {
14727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14728 }
14729 arg2 = static_cast< int >(val2);
14730 {
14731 arg3 = wxString_in_helper(obj2);
14732 if (arg3 == NULL) SWIG_fail;
14733 temp3 = true;
14734 }
14735 {
14736 PyThreadState* __tstate = wxPyBeginAllowThreads();
14737 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 resultobj = SWIG_Py_Void();
14742 {
14743 if (temp3)
14744 delete arg3;
14745 }
14746 return resultobj;
14747 fail:
14748 {
14749 if (temp3)
14750 delete arg3;
14751 }
14752 return NULL;
14753 }
14754
14755
14756 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj = 0;
14758 wxGrid *arg1 = (wxGrid *) 0 ;
14759 bool arg2 = (bool) true ;
14760 void *argp1 = 0 ;
14761 int res1 = 0 ;
14762 bool val2 ;
14763 int ecode2 = 0 ;
14764 PyObject * obj0 = 0 ;
14765 PyObject * obj1 = 0 ;
14766 char * kwnames[] = {
14767 (char *) "self",(char *) "enable", NULL
14768 };
14769
14770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
14771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14772 if (!SWIG_IsOK(res1)) {
14773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
14774 }
14775 arg1 = reinterpret_cast< wxGrid * >(argp1);
14776 if (obj1) {
14777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14778 if (!SWIG_IsOK(ecode2)) {
14779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14780 }
14781 arg2 = static_cast< bool >(val2);
14782 }
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 (arg1)->EnableGridLines(arg2);
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 resultobj = SWIG_Py_Void();
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14797 PyObject *resultobj = 0;
14798 wxGrid *arg1 = (wxGrid *) 0 ;
14799 bool result;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 PyObject *swig_obj[1] ;
14803
14804 if (!args) SWIG_fail;
14805 swig_obj[0] = args;
14806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14807 if (!SWIG_IsOK(res1)) {
14808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14809 }
14810 arg1 = reinterpret_cast< wxGrid * >(argp1);
14811 {
14812 PyThreadState* __tstate = wxPyBeginAllowThreads();
14813 result = (bool)(arg1)->GridLinesEnabled();
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 {
14818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14819 }
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14827 PyObject *resultobj = 0;
14828 wxGrid *arg1 = (wxGrid *) 0 ;
14829 int result;
14830 void *argp1 = 0 ;
14831 int res1 = 0 ;
14832 PyObject *swig_obj[1] ;
14833
14834 if (!args) SWIG_fail;
14835 swig_obj[0] = args;
14836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14837 if (!SWIG_IsOK(res1)) {
14838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14839 }
14840 arg1 = reinterpret_cast< wxGrid * >(argp1);
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 result = (int)(arg1)->GetDefaultRowSize();
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 resultobj = SWIG_From_int(static_cast< int >(result));
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj = 0;
14856 wxGrid *arg1 = (wxGrid *) 0 ;
14857 int arg2 ;
14858 int result;
14859 void *argp1 = 0 ;
14860 int res1 = 0 ;
14861 int val2 ;
14862 int ecode2 = 0 ;
14863 PyObject * obj0 = 0 ;
14864 PyObject * obj1 = 0 ;
14865 char * kwnames[] = {
14866 (char *) "self",(char *) "row", NULL
14867 };
14868
14869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14871 if (!SWIG_IsOK(res1)) {
14872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14873 }
14874 arg1 = reinterpret_cast< wxGrid * >(argp1);
14875 ecode2 = SWIG_AsVal_int(obj1, &val2);
14876 if (!SWIG_IsOK(ecode2)) {
14877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14878 }
14879 arg2 = static_cast< int >(val2);
14880 {
14881 PyThreadState* __tstate = wxPyBeginAllowThreads();
14882 result = (int)(arg1)->GetRowSize(arg2);
14883 wxPyEndAllowThreads(__tstate);
14884 if (PyErr_Occurred()) SWIG_fail;
14885 }
14886 resultobj = SWIG_From_int(static_cast< int >(result));
14887 return resultobj;
14888 fail:
14889 return NULL;
14890 }
14891
14892
14893 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14894 PyObject *resultobj = 0;
14895 wxGrid *arg1 = (wxGrid *) 0 ;
14896 int result;
14897 void *argp1 = 0 ;
14898 int res1 = 0 ;
14899 PyObject *swig_obj[1] ;
14900
14901 if (!args) SWIG_fail;
14902 swig_obj[0] = args;
14903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14904 if (!SWIG_IsOK(res1)) {
14905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14906 }
14907 arg1 = reinterpret_cast< wxGrid * >(argp1);
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (int)(arg1)->GetDefaultColSize();
14911 wxPyEndAllowThreads(__tstate);
14912 if (PyErr_Occurred()) SWIG_fail;
14913 }
14914 resultobj = SWIG_From_int(static_cast< int >(result));
14915 return resultobj;
14916 fail:
14917 return NULL;
14918 }
14919
14920
14921 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14922 PyObject *resultobj = 0;
14923 wxGrid *arg1 = (wxGrid *) 0 ;
14924 int arg2 ;
14925 int result;
14926 void *argp1 = 0 ;
14927 int res1 = 0 ;
14928 int val2 ;
14929 int ecode2 = 0 ;
14930 PyObject * obj0 = 0 ;
14931 PyObject * obj1 = 0 ;
14932 char * kwnames[] = {
14933 (char *) "self",(char *) "col", NULL
14934 };
14935
14936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14938 if (!SWIG_IsOK(res1)) {
14939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14940 }
14941 arg1 = reinterpret_cast< wxGrid * >(argp1);
14942 ecode2 = SWIG_AsVal_int(obj1, &val2);
14943 if (!SWIG_IsOK(ecode2)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14945 }
14946 arg2 = static_cast< int >(val2);
14947 {
14948 PyThreadState* __tstate = wxPyBeginAllowThreads();
14949 result = (int)(arg1)->GetColSize(arg2);
14950 wxPyEndAllowThreads(__tstate);
14951 if (PyErr_Occurred()) SWIG_fail;
14952 }
14953 resultobj = SWIG_From_int(static_cast< int >(result));
14954 return resultobj;
14955 fail:
14956 return NULL;
14957 }
14958
14959
14960 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14961 PyObject *resultobj = 0;
14962 wxGrid *arg1 = (wxGrid *) 0 ;
14963 wxColour result;
14964 void *argp1 = 0 ;
14965 int res1 = 0 ;
14966 PyObject *swig_obj[1] ;
14967
14968 if (!args) SWIG_fail;
14969 swig_obj[0] = args;
14970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14971 if (!SWIG_IsOK(res1)) {
14972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14973 }
14974 arg1 = reinterpret_cast< wxGrid * >(argp1);
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (arg1)->GetDefaultCellBackgroundColour();
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj = 0;
14990 wxGrid *arg1 = (wxGrid *) 0 ;
14991 int arg2 ;
14992 int arg3 ;
14993 wxColour result;
14994 void *argp1 = 0 ;
14995 int res1 = 0 ;
14996 int val2 ;
14997 int ecode2 = 0 ;
14998 int val3 ;
14999 int ecode3 = 0 ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 PyObject * obj2 = 0 ;
15003 char * kwnames[] = {
15004 (char *) "self",(char *) "row",(char *) "col", NULL
15005 };
15006
15007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15009 if (!SWIG_IsOK(res1)) {
15010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15011 }
15012 arg1 = reinterpret_cast< wxGrid * >(argp1);
15013 ecode2 = SWIG_AsVal_int(obj1, &val2);
15014 if (!SWIG_IsOK(ecode2)) {
15015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15016 }
15017 arg2 = static_cast< int >(val2);
15018 ecode3 = SWIG_AsVal_int(obj2, &val3);
15019 if (!SWIG_IsOK(ecode3)) {
15020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15021 }
15022 arg3 = static_cast< int >(val3);
15023 {
15024 PyThreadState* __tstate = wxPyBeginAllowThreads();
15025 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15026 wxPyEndAllowThreads(__tstate);
15027 if (PyErr_Occurred()) SWIG_fail;
15028 }
15029 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15030 return resultobj;
15031 fail:
15032 return NULL;
15033 }
15034
15035
15036 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15037 PyObject *resultobj = 0;
15038 wxGrid *arg1 = (wxGrid *) 0 ;
15039 wxColour result;
15040 void *argp1 = 0 ;
15041 int res1 = 0 ;
15042 PyObject *swig_obj[1] ;
15043
15044 if (!args) SWIG_fail;
15045 swig_obj[0] = args;
15046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15047 if (!SWIG_IsOK(res1)) {
15048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15049 }
15050 arg1 = reinterpret_cast< wxGrid * >(argp1);
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (arg1)->GetDefaultCellTextColour();
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj = 0;
15066 wxGrid *arg1 = (wxGrid *) 0 ;
15067 int arg2 ;
15068 int arg3 ;
15069 wxColour result;
15070 void *argp1 = 0 ;
15071 int res1 = 0 ;
15072 int val2 ;
15073 int ecode2 = 0 ;
15074 int val3 ;
15075 int ecode3 = 0 ;
15076 PyObject * obj0 = 0 ;
15077 PyObject * obj1 = 0 ;
15078 PyObject * obj2 = 0 ;
15079 char * kwnames[] = {
15080 (char *) "self",(char *) "row",(char *) "col", NULL
15081 };
15082
15083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15085 if (!SWIG_IsOK(res1)) {
15086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15087 }
15088 arg1 = reinterpret_cast< wxGrid * >(argp1);
15089 ecode2 = SWIG_AsVal_int(obj1, &val2);
15090 if (!SWIG_IsOK(ecode2)) {
15091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15092 }
15093 arg2 = static_cast< int >(val2);
15094 ecode3 = SWIG_AsVal_int(obj2, &val3);
15095 if (!SWIG_IsOK(ecode3)) {
15096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15097 }
15098 arg3 = static_cast< int >(val3);
15099 {
15100 PyThreadState* __tstate = wxPyBeginAllowThreads();
15101 result = (arg1)->GetCellTextColour(arg2,arg3);
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15113 PyObject *resultobj = 0;
15114 wxGrid *arg1 = (wxGrid *) 0 ;
15115 wxFont result;
15116 void *argp1 = 0 ;
15117 int res1 = 0 ;
15118 PyObject *swig_obj[1] ;
15119
15120 if (!args) SWIG_fail;
15121 swig_obj[0] = args;
15122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15123 if (!SWIG_IsOK(res1)) {
15124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15125 }
15126 arg1 = reinterpret_cast< wxGrid * >(argp1);
15127 {
15128 PyThreadState* __tstate = wxPyBeginAllowThreads();
15129 result = (arg1)->GetDefaultCellFont();
15130 wxPyEndAllowThreads(__tstate);
15131 if (PyErr_Occurred()) SWIG_fail;
15132 }
15133 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15134 return resultobj;
15135 fail:
15136 return NULL;
15137 }
15138
15139
15140 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15141 PyObject *resultobj = 0;
15142 wxGrid *arg1 = (wxGrid *) 0 ;
15143 int arg2 ;
15144 int arg3 ;
15145 wxFont result;
15146 void *argp1 = 0 ;
15147 int res1 = 0 ;
15148 int val2 ;
15149 int ecode2 = 0 ;
15150 int val3 ;
15151 int ecode3 = 0 ;
15152 PyObject * obj0 = 0 ;
15153 PyObject * obj1 = 0 ;
15154 PyObject * obj2 = 0 ;
15155 char * kwnames[] = {
15156 (char *) "self",(char *) "row",(char *) "col", NULL
15157 };
15158
15159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15161 if (!SWIG_IsOK(res1)) {
15162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15163 }
15164 arg1 = reinterpret_cast< wxGrid * >(argp1);
15165 ecode2 = SWIG_AsVal_int(obj1, &val2);
15166 if (!SWIG_IsOK(ecode2)) {
15167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15168 }
15169 arg2 = static_cast< int >(val2);
15170 ecode3 = SWIG_AsVal_int(obj2, &val3);
15171 if (!SWIG_IsOK(ecode3)) {
15172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15173 }
15174 arg3 = static_cast< int >(val3);
15175 {
15176 PyThreadState* __tstate = wxPyBeginAllowThreads();
15177 result = (arg1)->GetCellFont(arg2,arg3);
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15182 return resultobj;
15183 fail:
15184 return NULL;
15185 }
15186
15187
15188 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15189 PyObject *resultobj = 0;
15190 wxGrid *arg1 = (wxGrid *) 0 ;
15191 int *arg2 = (int *) 0 ;
15192 int *arg3 = (int *) 0 ;
15193 void *argp1 = 0 ;
15194 int res1 = 0 ;
15195 int temp2 ;
15196 int res2 = SWIG_TMPOBJ ;
15197 int temp3 ;
15198 int res3 = SWIG_TMPOBJ ;
15199 PyObject *swig_obj[1] ;
15200
15201 arg2 = &temp2;
15202 arg3 = &temp3;
15203 if (!args) SWIG_fail;
15204 swig_obj[0] = args;
15205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15208 }
15209 arg1 = reinterpret_cast< wxGrid * >(argp1);
15210 {
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 resultobj = SWIG_Py_Void();
15217 if (SWIG_IsTmpObj(res2)) {
15218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15219 } else {
15220 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15222 }
15223 if (SWIG_IsTmpObj(res3)) {
15224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15225 } else {
15226 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15228 }
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj = 0;
15237 wxGrid *arg1 = (wxGrid *) 0 ;
15238 int arg2 ;
15239 int arg3 ;
15240 int *arg4 = (int *) 0 ;
15241 int *arg5 = (int *) 0 ;
15242 void *argp1 = 0 ;
15243 int res1 = 0 ;
15244 int val2 ;
15245 int ecode2 = 0 ;
15246 int val3 ;
15247 int ecode3 = 0 ;
15248 int temp4 ;
15249 int res4 = SWIG_TMPOBJ ;
15250 int temp5 ;
15251 int res5 = SWIG_TMPOBJ ;
15252 PyObject * obj0 = 0 ;
15253 PyObject * obj1 = 0 ;
15254 PyObject * obj2 = 0 ;
15255 char * kwnames[] = {
15256 (char *) "self",(char *) "row",(char *) "col", NULL
15257 };
15258
15259 arg4 = &temp4;
15260 arg5 = &temp5;
15261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15263 if (!SWIG_IsOK(res1)) {
15264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15265 }
15266 arg1 = reinterpret_cast< wxGrid * >(argp1);
15267 ecode2 = SWIG_AsVal_int(obj1, &val2);
15268 if (!SWIG_IsOK(ecode2)) {
15269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15270 }
15271 arg2 = static_cast< int >(val2);
15272 ecode3 = SWIG_AsVal_int(obj2, &val3);
15273 if (!SWIG_IsOK(ecode3)) {
15274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15275 }
15276 arg3 = static_cast< int >(val3);
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15280 wxPyEndAllowThreads(__tstate);
15281 if (PyErr_Occurred()) SWIG_fail;
15282 }
15283 resultobj = SWIG_Py_Void();
15284 if (SWIG_IsTmpObj(res4)) {
15285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15286 } else {
15287 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15289 }
15290 if (SWIG_IsTmpObj(res5)) {
15291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15292 } else {
15293 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15295 }
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15303 PyObject *resultobj = 0;
15304 wxGrid *arg1 = (wxGrid *) 0 ;
15305 bool result;
15306 void *argp1 = 0 ;
15307 int res1 = 0 ;
15308 PyObject *swig_obj[1] ;
15309
15310 if (!args) SWIG_fail;
15311 swig_obj[0] = args;
15312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15315 }
15316 arg1 = reinterpret_cast< wxGrid * >(argp1);
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (bool)(arg1)->GetDefaultCellOverflow();
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 {
15324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15325 }
15326 return resultobj;
15327 fail:
15328 return NULL;
15329 }
15330
15331
15332 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15333 PyObject *resultobj = 0;
15334 wxGrid *arg1 = (wxGrid *) 0 ;
15335 int arg2 ;
15336 int arg3 ;
15337 bool result;
15338 void *argp1 = 0 ;
15339 int res1 = 0 ;
15340 int val2 ;
15341 int ecode2 = 0 ;
15342 int val3 ;
15343 int ecode3 = 0 ;
15344 PyObject * obj0 = 0 ;
15345 PyObject * obj1 = 0 ;
15346 PyObject * obj2 = 0 ;
15347 char * kwnames[] = {
15348 (char *) "self",(char *) "row",(char *) "col", NULL
15349 };
15350
15351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15353 if (!SWIG_IsOK(res1)) {
15354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15355 }
15356 arg1 = reinterpret_cast< wxGrid * >(argp1);
15357 ecode2 = SWIG_AsVal_int(obj1, &val2);
15358 if (!SWIG_IsOK(ecode2)) {
15359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15360 }
15361 arg2 = static_cast< int >(val2);
15362 ecode3 = SWIG_AsVal_int(obj2, &val3);
15363 if (!SWIG_IsOK(ecode3)) {
15364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15365 }
15366 arg3 = static_cast< int >(val3);
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15370 wxPyEndAllowThreads(__tstate);
15371 if (PyErr_Occurred()) SWIG_fail;
15372 }
15373 {
15374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15375 }
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15383 PyObject *resultobj = 0;
15384 wxGrid *arg1 = (wxGrid *) 0 ;
15385 int arg2 ;
15386 int arg3 ;
15387 int *arg4 = (int *) 0 ;
15388 int *arg5 = (int *) 0 ;
15389 void *argp1 = 0 ;
15390 int res1 = 0 ;
15391 int val2 ;
15392 int ecode2 = 0 ;
15393 int val3 ;
15394 int ecode3 = 0 ;
15395 int temp4 ;
15396 int res4 = SWIG_TMPOBJ ;
15397 int temp5 ;
15398 int res5 = SWIG_TMPOBJ ;
15399 PyObject * obj0 = 0 ;
15400 PyObject * obj1 = 0 ;
15401 PyObject * obj2 = 0 ;
15402 char * kwnames[] = {
15403 (char *) "self",(char *) "row",(char *) "col", NULL
15404 };
15405
15406 arg4 = &temp4;
15407 arg5 = &temp5;
15408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",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_GetCellSize" "', 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_GetCellSize" "', 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_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15422 }
15423 arg3 = static_cast< int >(val3);
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15427 wxPyEndAllowThreads(__tstate);
15428 if (PyErr_Occurred()) SWIG_fail;
15429 }
15430 resultobj = SWIG_Py_Void();
15431 if (SWIG_IsTmpObj(res4)) {
15432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15433 } else {
15434 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15436 }
15437 if (SWIG_IsTmpObj(res5)) {
15438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15439 } else {
15440 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15442 }
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj = 0;
15451 wxGrid *arg1 = (wxGrid *) 0 ;
15452 int arg2 ;
15453 bool arg3 = (bool) false ;
15454 void *argp1 = 0 ;
15455 int res1 = 0 ;
15456 int val2 ;
15457 int ecode2 = 0 ;
15458 bool val3 ;
15459 int ecode3 = 0 ;
15460 PyObject * obj0 = 0 ;
15461 PyObject * obj1 = 0 ;
15462 PyObject * obj2 = 0 ;
15463 char * kwnames[] = {
15464 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15465 };
15466
15467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15469 if (!SWIG_IsOK(res1)) {
15470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15471 }
15472 arg1 = reinterpret_cast< wxGrid * >(argp1);
15473 ecode2 = SWIG_AsVal_int(obj1, &val2);
15474 if (!SWIG_IsOK(ecode2)) {
15475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15476 }
15477 arg2 = static_cast< int >(val2);
15478 if (obj2) {
15479 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15480 if (!SWIG_IsOK(ecode3)) {
15481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15482 }
15483 arg3 = static_cast< bool >(val3);
15484 }
15485 {
15486 PyThreadState* __tstate = wxPyBeginAllowThreads();
15487 (arg1)->SetDefaultRowSize(arg2,arg3);
15488 wxPyEndAllowThreads(__tstate);
15489 if (PyErr_Occurred()) SWIG_fail;
15490 }
15491 resultobj = SWIG_Py_Void();
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj = 0;
15500 wxGrid *arg1 = (wxGrid *) 0 ;
15501 int arg2 ;
15502 int arg3 ;
15503 void *argp1 = 0 ;
15504 int res1 = 0 ;
15505 int val2 ;
15506 int ecode2 = 0 ;
15507 int val3 ;
15508 int ecode3 = 0 ;
15509 PyObject * obj0 = 0 ;
15510 PyObject * obj1 = 0 ;
15511 PyObject * obj2 = 0 ;
15512 char * kwnames[] = {
15513 (char *) "self",(char *) "row",(char *) "height", NULL
15514 };
15515
15516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15520 }
15521 arg1 = reinterpret_cast< wxGrid * >(argp1);
15522 ecode2 = SWIG_AsVal_int(obj1, &val2);
15523 if (!SWIG_IsOK(ecode2)) {
15524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15525 }
15526 arg2 = static_cast< int >(val2);
15527 ecode3 = SWIG_AsVal_int(obj2, &val3);
15528 if (!SWIG_IsOK(ecode3)) {
15529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15530 }
15531 arg3 = static_cast< int >(val3);
15532 {
15533 PyThreadState* __tstate = wxPyBeginAllowThreads();
15534 (arg1)->SetRowSize(arg2,arg3);
15535 wxPyEndAllowThreads(__tstate);
15536 if (PyErr_Occurred()) SWIG_fail;
15537 }
15538 resultobj = SWIG_Py_Void();
15539 return resultobj;
15540 fail:
15541 return NULL;
15542 }
15543
15544
15545 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15546 PyObject *resultobj = 0;
15547 wxGrid *arg1 = (wxGrid *) 0 ;
15548 int arg2 ;
15549 bool arg3 = (bool) false ;
15550 void *argp1 = 0 ;
15551 int res1 = 0 ;
15552 int val2 ;
15553 int ecode2 = 0 ;
15554 bool val3 ;
15555 int ecode3 = 0 ;
15556 PyObject * obj0 = 0 ;
15557 PyObject * obj1 = 0 ;
15558 PyObject * obj2 = 0 ;
15559 char * kwnames[] = {
15560 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15561 };
15562
15563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15565 if (!SWIG_IsOK(res1)) {
15566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15567 }
15568 arg1 = reinterpret_cast< wxGrid * >(argp1);
15569 ecode2 = SWIG_AsVal_int(obj1, &val2);
15570 if (!SWIG_IsOK(ecode2)) {
15571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15572 }
15573 arg2 = static_cast< int >(val2);
15574 if (obj2) {
15575 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15576 if (!SWIG_IsOK(ecode3)) {
15577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15578 }
15579 arg3 = static_cast< bool >(val3);
15580 }
15581 {
15582 PyThreadState* __tstate = wxPyBeginAllowThreads();
15583 (arg1)->SetDefaultColSize(arg2,arg3);
15584 wxPyEndAllowThreads(__tstate);
15585 if (PyErr_Occurred()) SWIG_fail;
15586 }
15587 resultobj = SWIG_Py_Void();
15588 return resultobj;
15589 fail:
15590 return NULL;
15591 }
15592
15593
15594 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15595 PyObject *resultobj = 0;
15596 wxGrid *arg1 = (wxGrid *) 0 ;
15597 int arg2 ;
15598 int arg3 ;
15599 void *argp1 = 0 ;
15600 int res1 = 0 ;
15601 int val2 ;
15602 int ecode2 = 0 ;
15603 int val3 ;
15604 int ecode3 = 0 ;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 PyObject * obj2 = 0 ;
15608 char * kwnames[] = {
15609 (char *) "self",(char *) "col",(char *) "width", NULL
15610 };
15611
15612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15614 if (!SWIG_IsOK(res1)) {
15615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15616 }
15617 arg1 = reinterpret_cast< wxGrid * >(argp1);
15618 ecode2 = SWIG_AsVal_int(obj1, &val2);
15619 if (!SWIG_IsOK(ecode2)) {
15620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15621 }
15622 arg2 = static_cast< int >(val2);
15623 ecode3 = SWIG_AsVal_int(obj2, &val3);
15624 if (!SWIG_IsOK(ecode3)) {
15625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15626 }
15627 arg3 = static_cast< int >(val3);
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 (arg1)->SetColSize(arg2,arg3);
15631 wxPyEndAllowThreads(__tstate);
15632 if (PyErr_Occurred()) SWIG_fail;
15633 }
15634 resultobj = SWIG_Py_Void();
15635 return resultobj;
15636 fail:
15637 return NULL;
15638 }
15639
15640
15641 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15642 PyObject *resultobj = 0;
15643 wxGrid *arg1 = (wxGrid *) 0 ;
15644 int arg2 ;
15645 int result;
15646 void *argp1 = 0 ;
15647 int res1 = 0 ;
15648 int val2 ;
15649 int ecode2 = 0 ;
15650 PyObject * obj0 = 0 ;
15651 PyObject * obj1 = 0 ;
15652 char * kwnames[] = {
15653 (char *) "self",(char *) "colPos", NULL
15654 };
15655
15656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15658 if (!SWIG_IsOK(res1)) {
15659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15660 }
15661 arg1 = reinterpret_cast< wxGrid * >(argp1);
15662 ecode2 = SWIG_AsVal_int(obj1, &val2);
15663 if (!SWIG_IsOK(ecode2)) {
15664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15665 }
15666 arg2 = static_cast< int >(val2);
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15670 wxPyEndAllowThreads(__tstate);
15671 if (PyErr_Occurred()) SWIG_fail;
15672 }
15673 resultobj = SWIG_From_int(static_cast< int >(result));
15674 return resultobj;
15675 fail:
15676 return NULL;
15677 }
15678
15679
15680 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15681 PyObject *resultobj = 0;
15682 wxGrid *arg1 = (wxGrid *) 0 ;
15683 int arg2 ;
15684 int arg3 ;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 int val2 ;
15688 int ecode2 = 0 ;
15689 int val3 ;
15690 int ecode3 = 0 ;
15691 PyObject * obj0 = 0 ;
15692 PyObject * obj1 = 0 ;
15693 PyObject * obj2 = 0 ;
15694 char * kwnames[] = {
15695 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15696 };
15697
15698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15700 if (!SWIG_IsOK(res1)) {
15701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15702 }
15703 arg1 = reinterpret_cast< wxGrid * >(argp1);
15704 ecode2 = SWIG_AsVal_int(obj1, &val2);
15705 if (!SWIG_IsOK(ecode2)) {
15706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15707 }
15708 arg2 = static_cast< int >(val2);
15709 ecode3 = SWIG_AsVal_int(obj2, &val3);
15710 if (!SWIG_IsOK(ecode3)) {
15711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15712 }
15713 arg3 = static_cast< int >(val3);
15714 {
15715 PyThreadState* __tstate = wxPyBeginAllowThreads();
15716 (arg1)->SetColPos(arg2,arg3);
15717 wxPyEndAllowThreads(__tstate);
15718 if (PyErr_Occurred()) SWIG_fail;
15719 }
15720 resultobj = SWIG_Py_Void();
15721 return resultobj;
15722 fail:
15723 return NULL;
15724 }
15725
15726
15727 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15728 PyObject *resultobj = 0;
15729 wxGrid *arg1 = (wxGrid *) 0 ;
15730 int arg2 ;
15731 int result;
15732 void *argp1 = 0 ;
15733 int res1 = 0 ;
15734 int val2 ;
15735 int ecode2 = 0 ;
15736 PyObject * obj0 = 0 ;
15737 PyObject * obj1 = 0 ;
15738 char * kwnames[] = {
15739 (char *) "self",(char *) "colID", NULL
15740 };
15741
15742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
15743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15744 if (!SWIG_IsOK(res1)) {
15745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
15746 }
15747 arg1 = reinterpret_cast< wxGrid * >(argp1);
15748 ecode2 = SWIG_AsVal_int(obj1, &val2);
15749 if (!SWIG_IsOK(ecode2)) {
15750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
15751 }
15752 arg2 = static_cast< int >(val2);
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
15756 wxPyEndAllowThreads(__tstate);
15757 if (PyErr_Occurred()) SWIG_fail;
15758 }
15759 resultobj = SWIG_From_int(static_cast< int >(result));
15760 return resultobj;
15761 fail:
15762 return NULL;
15763 }
15764
15765
15766 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15767 PyObject *resultobj = 0;
15768 wxGrid *arg1 = (wxGrid *) 0 ;
15769 int arg2 ;
15770 bool arg3 = (bool) true ;
15771 void *argp1 = 0 ;
15772 int res1 = 0 ;
15773 int val2 ;
15774 int ecode2 = 0 ;
15775 bool val3 ;
15776 int ecode3 = 0 ;
15777 PyObject * obj0 = 0 ;
15778 PyObject * obj1 = 0 ;
15779 PyObject * obj2 = 0 ;
15780 char * kwnames[] = {
15781 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15782 };
15783
15784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15786 if (!SWIG_IsOK(res1)) {
15787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15788 }
15789 arg1 = reinterpret_cast< wxGrid * >(argp1);
15790 ecode2 = SWIG_AsVal_int(obj1, &val2);
15791 if (!SWIG_IsOK(ecode2)) {
15792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15793 }
15794 arg2 = static_cast< int >(val2);
15795 if (obj2) {
15796 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15797 if (!SWIG_IsOK(ecode3)) {
15798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15799 }
15800 arg3 = static_cast< bool >(val3);
15801 }
15802 {
15803 PyThreadState* __tstate = wxPyBeginAllowThreads();
15804 (arg1)->AutoSizeColumn(arg2,arg3);
15805 wxPyEndAllowThreads(__tstate);
15806 if (PyErr_Occurred()) SWIG_fail;
15807 }
15808 resultobj = SWIG_Py_Void();
15809 return resultobj;
15810 fail:
15811 return NULL;
15812 }
15813
15814
15815 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15816 PyObject *resultobj = 0;
15817 wxGrid *arg1 = (wxGrid *) 0 ;
15818 int arg2 ;
15819 bool arg3 = (bool) true ;
15820 void *argp1 = 0 ;
15821 int res1 = 0 ;
15822 int val2 ;
15823 int ecode2 = 0 ;
15824 bool val3 ;
15825 int ecode3 = 0 ;
15826 PyObject * obj0 = 0 ;
15827 PyObject * obj1 = 0 ;
15828 PyObject * obj2 = 0 ;
15829 char * kwnames[] = {
15830 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15831 };
15832
15833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15835 if (!SWIG_IsOK(res1)) {
15836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15837 }
15838 arg1 = reinterpret_cast< wxGrid * >(argp1);
15839 ecode2 = SWIG_AsVal_int(obj1, &val2);
15840 if (!SWIG_IsOK(ecode2)) {
15841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15842 }
15843 arg2 = static_cast< int >(val2);
15844 if (obj2) {
15845 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15846 if (!SWIG_IsOK(ecode3)) {
15847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15848 }
15849 arg3 = static_cast< bool >(val3);
15850 }
15851 {
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 (arg1)->AutoSizeRow(arg2,arg3);
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 resultobj = SWIG_Py_Void();
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15865 PyObject *resultobj = 0;
15866 wxGrid *arg1 = (wxGrid *) 0 ;
15867 bool arg2 = (bool) true ;
15868 void *argp1 = 0 ;
15869 int res1 = 0 ;
15870 bool val2 ;
15871 int ecode2 = 0 ;
15872 PyObject * obj0 = 0 ;
15873 PyObject * obj1 = 0 ;
15874 char * kwnames[] = {
15875 (char *) "self",(char *) "setAsMin", NULL
15876 };
15877
15878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15880 if (!SWIG_IsOK(res1)) {
15881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15882 }
15883 arg1 = reinterpret_cast< wxGrid * >(argp1);
15884 if (obj1) {
15885 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15886 if (!SWIG_IsOK(ecode2)) {
15887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15888 }
15889 arg2 = static_cast< bool >(val2);
15890 }
15891 {
15892 PyThreadState* __tstate = wxPyBeginAllowThreads();
15893 (arg1)->AutoSizeColumns(arg2);
15894 wxPyEndAllowThreads(__tstate);
15895 if (PyErr_Occurred()) SWIG_fail;
15896 }
15897 resultobj = SWIG_Py_Void();
15898 return resultobj;
15899 fail:
15900 return NULL;
15901 }
15902
15903
15904 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15905 PyObject *resultobj = 0;
15906 wxGrid *arg1 = (wxGrid *) 0 ;
15907 bool arg2 = (bool) true ;
15908 void *argp1 = 0 ;
15909 int res1 = 0 ;
15910 bool val2 ;
15911 int ecode2 = 0 ;
15912 PyObject * obj0 = 0 ;
15913 PyObject * obj1 = 0 ;
15914 char * kwnames[] = {
15915 (char *) "self",(char *) "setAsMin", NULL
15916 };
15917
15918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15920 if (!SWIG_IsOK(res1)) {
15921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15922 }
15923 arg1 = reinterpret_cast< wxGrid * >(argp1);
15924 if (obj1) {
15925 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15926 if (!SWIG_IsOK(ecode2)) {
15927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15928 }
15929 arg2 = static_cast< bool >(val2);
15930 }
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 (arg1)->AutoSizeRows(arg2);
15934 wxPyEndAllowThreads(__tstate);
15935 if (PyErr_Occurred()) SWIG_fail;
15936 }
15937 resultobj = SWIG_Py_Void();
15938 return resultobj;
15939 fail:
15940 return NULL;
15941 }
15942
15943
15944 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15945 PyObject *resultobj = 0;
15946 wxGrid *arg1 = (wxGrid *) 0 ;
15947 void *argp1 = 0 ;
15948 int res1 = 0 ;
15949 PyObject *swig_obj[1] ;
15950
15951 if (!args) SWIG_fail;
15952 swig_obj[0] = args;
15953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15954 if (!SWIG_IsOK(res1)) {
15955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15956 }
15957 arg1 = reinterpret_cast< wxGrid * >(argp1);
15958 {
15959 PyThreadState* __tstate = wxPyBeginAllowThreads();
15960 (arg1)->AutoSize();
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 resultobj = SWIG_Py_Void();
15965 return resultobj;
15966 fail:
15967 return NULL;
15968 }
15969
15970
15971 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15972 PyObject *resultobj = 0;
15973 wxGrid *arg1 = (wxGrid *) 0 ;
15974 int arg2 ;
15975 void *argp1 = 0 ;
15976 int res1 = 0 ;
15977 int val2 ;
15978 int ecode2 = 0 ;
15979 PyObject * obj0 = 0 ;
15980 PyObject * obj1 = 0 ;
15981 char * kwnames[] = {
15982 (char *) "self",(char *) "row", NULL
15983 };
15984
15985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15987 if (!SWIG_IsOK(res1)) {
15988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15989 }
15990 arg1 = reinterpret_cast< wxGrid * >(argp1);
15991 ecode2 = SWIG_AsVal_int(obj1, &val2);
15992 if (!SWIG_IsOK(ecode2)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15994 }
15995 arg2 = static_cast< int >(val2);
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 (arg1)->AutoSizeRowLabelSize(arg2);
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_Py_Void();
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16010 PyObject *resultobj = 0;
16011 wxGrid *arg1 = (wxGrid *) 0 ;
16012 int arg2 ;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 int val2 ;
16016 int ecode2 = 0 ;
16017 PyObject * obj0 = 0 ;
16018 PyObject * obj1 = 0 ;
16019 char * kwnames[] = {
16020 (char *) "self",(char *) "col", NULL
16021 };
16022
16023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16025 if (!SWIG_IsOK(res1)) {
16026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16027 }
16028 arg1 = reinterpret_cast< wxGrid * >(argp1);
16029 ecode2 = SWIG_AsVal_int(obj1, &val2);
16030 if (!SWIG_IsOK(ecode2)) {
16031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16032 }
16033 arg2 = static_cast< int >(val2);
16034 {
16035 PyThreadState* __tstate = wxPyBeginAllowThreads();
16036 (arg1)->AutoSizeColLabelSize(arg2);
16037 wxPyEndAllowThreads(__tstate);
16038 if (PyErr_Occurred()) SWIG_fail;
16039 }
16040 resultobj = SWIG_Py_Void();
16041 return resultobj;
16042 fail:
16043 return NULL;
16044 }
16045
16046
16047 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16048 PyObject *resultobj = 0;
16049 wxGrid *arg1 = (wxGrid *) 0 ;
16050 int arg2 ;
16051 int arg3 ;
16052 void *argp1 = 0 ;
16053 int res1 = 0 ;
16054 int val2 ;
16055 int ecode2 = 0 ;
16056 int val3 ;
16057 int ecode3 = 0 ;
16058 PyObject * obj0 = 0 ;
16059 PyObject * obj1 = 0 ;
16060 PyObject * obj2 = 0 ;
16061 char * kwnames[] = {
16062 (char *) "self",(char *) "col",(char *) "width", NULL
16063 };
16064
16065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16069 }
16070 arg1 = reinterpret_cast< wxGrid * >(argp1);
16071 ecode2 = SWIG_AsVal_int(obj1, &val2);
16072 if (!SWIG_IsOK(ecode2)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16074 }
16075 arg2 = static_cast< int >(val2);
16076 ecode3 = SWIG_AsVal_int(obj2, &val3);
16077 if (!SWIG_IsOK(ecode3)) {
16078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16079 }
16080 arg3 = static_cast< int >(val3);
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 (arg1)->SetColMinimalWidth(arg2,arg3);
16084 wxPyEndAllowThreads(__tstate);
16085 if (PyErr_Occurred()) SWIG_fail;
16086 }
16087 resultobj = SWIG_Py_Void();
16088 return resultobj;
16089 fail:
16090 return NULL;
16091 }
16092
16093
16094 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16095 PyObject *resultobj = 0;
16096 wxGrid *arg1 = (wxGrid *) 0 ;
16097 int arg2 ;
16098 int arg3 ;
16099 void *argp1 = 0 ;
16100 int res1 = 0 ;
16101 int val2 ;
16102 int ecode2 = 0 ;
16103 int val3 ;
16104 int ecode3 = 0 ;
16105 PyObject * obj0 = 0 ;
16106 PyObject * obj1 = 0 ;
16107 PyObject * obj2 = 0 ;
16108 char * kwnames[] = {
16109 (char *) "self",(char *) "row",(char *) "width", NULL
16110 };
16111
16112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16114 if (!SWIG_IsOK(res1)) {
16115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16116 }
16117 arg1 = reinterpret_cast< wxGrid * >(argp1);
16118 ecode2 = SWIG_AsVal_int(obj1, &val2);
16119 if (!SWIG_IsOK(ecode2)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16121 }
16122 arg2 = static_cast< int >(val2);
16123 ecode3 = SWIG_AsVal_int(obj2, &val3);
16124 if (!SWIG_IsOK(ecode3)) {
16125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16126 }
16127 arg3 = static_cast< int >(val3);
16128 {
16129 PyThreadState* __tstate = wxPyBeginAllowThreads();
16130 (arg1)->SetRowMinimalHeight(arg2,arg3);
16131 wxPyEndAllowThreads(__tstate);
16132 if (PyErr_Occurred()) SWIG_fail;
16133 }
16134 resultobj = SWIG_Py_Void();
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj = 0;
16143 wxGrid *arg1 = (wxGrid *) 0 ;
16144 int arg2 ;
16145 void *argp1 = 0 ;
16146 int res1 = 0 ;
16147 int val2 ;
16148 int ecode2 = 0 ;
16149 PyObject * obj0 = 0 ;
16150 PyObject * obj1 = 0 ;
16151 char * kwnames[] = {
16152 (char *) "self",(char *) "width", NULL
16153 };
16154
16155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16157 if (!SWIG_IsOK(res1)) {
16158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16159 }
16160 arg1 = reinterpret_cast< wxGrid * >(argp1);
16161 ecode2 = SWIG_AsVal_int(obj1, &val2);
16162 if (!SWIG_IsOK(ecode2)) {
16163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16164 }
16165 arg2 = static_cast< int >(val2);
16166 {
16167 PyThreadState* __tstate = wxPyBeginAllowThreads();
16168 (arg1)->SetColMinimalAcceptableWidth(arg2);
16169 wxPyEndAllowThreads(__tstate);
16170 if (PyErr_Occurred()) SWIG_fail;
16171 }
16172 resultobj = SWIG_Py_Void();
16173 return resultobj;
16174 fail:
16175 return NULL;
16176 }
16177
16178
16179 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16180 PyObject *resultobj = 0;
16181 wxGrid *arg1 = (wxGrid *) 0 ;
16182 int arg2 ;
16183 void *argp1 = 0 ;
16184 int res1 = 0 ;
16185 int val2 ;
16186 int ecode2 = 0 ;
16187 PyObject * obj0 = 0 ;
16188 PyObject * obj1 = 0 ;
16189 char * kwnames[] = {
16190 (char *) "self",(char *) "width", NULL
16191 };
16192
16193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16195 if (!SWIG_IsOK(res1)) {
16196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16197 }
16198 arg1 = reinterpret_cast< wxGrid * >(argp1);
16199 ecode2 = SWIG_AsVal_int(obj1, &val2);
16200 if (!SWIG_IsOK(ecode2)) {
16201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16202 }
16203 arg2 = static_cast< int >(val2);
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16207 wxPyEndAllowThreads(__tstate);
16208 if (PyErr_Occurred()) SWIG_fail;
16209 }
16210 resultobj = SWIG_Py_Void();
16211 return resultobj;
16212 fail:
16213 return NULL;
16214 }
16215
16216
16217 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16218 PyObject *resultobj = 0;
16219 wxGrid *arg1 = (wxGrid *) 0 ;
16220 int result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 PyObject *swig_obj[1] ;
16224
16225 if (!args) SWIG_fail;
16226 swig_obj[0] = args;
16227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16228 if (!SWIG_IsOK(res1)) {
16229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16230 }
16231 arg1 = reinterpret_cast< wxGrid * >(argp1);
16232 {
16233 PyThreadState* __tstate = wxPyBeginAllowThreads();
16234 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16235 wxPyEndAllowThreads(__tstate);
16236 if (PyErr_Occurred()) SWIG_fail;
16237 }
16238 resultobj = SWIG_From_int(static_cast< int >(result));
16239 return resultobj;
16240 fail:
16241 return NULL;
16242 }
16243
16244
16245 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16246 PyObject *resultobj = 0;
16247 wxGrid *arg1 = (wxGrid *) 0 ;
16248 int result;
16249 void *argp1 = 0 ;
16250 int res1 = 0 ;
16251 PyObject *swig_obj[1] ;
16252
16253 if (!args) SWIG_fail;
16254 swig_obj[0] = args;
16255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16256 if (!SWIG_IsOK(res1)) {
16257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16258 }
16259 arg1 = reinterpret_cast< wxGrid * >(argp1);
16260 {
16261 PyThreadState* __tstate = wxPyBeginAllowThreads();
16262 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16263 wxPyEndAllowThreads(__tstate);
16264 if (PyErr_Occurred()) SWIG_fail;
16265 }
16266 resultobj = SWIG_From_int(static_cast< int >(result));
16267 return resultobj;
16268 fail:
16269 return NULL;
16270 }
16271
16272
16273 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16274 PyObject *resultobj = 0;
16275 wxGrid *arg1 = (wxGrid *) 0 ;
16276 wxColour *arg2 = 0 ;
16277 void *argp1 = 0 ;
16278 int res1 = 0 ;
16279 wxColour temp2 ;
16280 PyObject * obj0 = 0 ;
16281 PyObject * obj1 = 0 ;
16282 char * kwnames[] = {
16283 (char *) "self",(char *)"arg2", NULL
16284 };
16285
16286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16288 if (!SWIG_IsOK(res1)) {
16289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16290 }
16291 arg1 = reinterpret_cast< wxGrid * >(argp1);
16292 {
16293 arg2 = &temp2;
16294 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16295 }
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 resultobj = SWIG_Py_Void();
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj = 0;
16311 wxGrid *arg1 = (wxGrid *) 0 ;
16312 int arg2 ;
16313 int arg3 ;
16314 wxColour *arg4 = 0 ;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 int val2 ;
16318 int ecode2 = 0 ;
16319 int val3 ;
16320 int ecode3 = 0 ;
16321 wxColour temp4 ;
16322 PyObject * obj0 = 0 ;
16323 PyObject * obj1 = 0 ;
16324 PyObject * obj2 = 0 ;
16325 PyObject * obj3 = 0 ;
16326 char * kwnames[] = {
16327 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16328 };
16329
16330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16332 if (!SWIG_IsOK(res1)) {
16333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16334 }
16335 arg1 = reinterpret_cast< wxGrid * >(argp1);
16336 ecode2 = SWIG_AsVal_int(obj1, &val2);
16337 if (!SWIG_IsOK(ecode2)) {
16338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16339 }
16340 arg2 = static_cast< int >(val2);
16341 ecode3 = SWIG_AsVal_int(obj2, &val3);
16342 if (!SWIG_IsOK(ecode3)) {
16343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16344 }
16345 arg3 = static_cast< int >(val3);
16346 {
16347 arg4 = &temp4;
16348 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16349 }
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 resultobj = SWIG_Py_Void();
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj = 0;
16365 wxGrid *arg1 = (wxGrid *) 0 ;
16366 wxColour *arg2 = 0 ;
16367 void *argp1 = 0 ;
16368 int res1 = 0 ;
16369 wxColour temp2 ;
16370 PyObject * obj0 = 0 ;
16371 PyObject * obj1 = 0 ;
16372 char * kwnames[] = {
16373 (char *) "self",(char *)"arg2", NULL
16374 };
16375
16376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16378 if (!SWIG_IsOK(res1)) {
16379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16380 }
16381 arg1 = reinterpret_cast< wxGrid * >(argp1);
16382 {
16383 arg2 = &temp2;
16384 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16385 }
16386 {
16387 PyThreadState* __tstate = wxPyBeginAllowThreads();
16388 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 resultobj = SWIG_Py_Void();
16393 return resultobj;
16394 fail:
16395 return NULL;
16396 }
16397
16398
16399 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16400 PyObject *resultobj = 0;
16401 wxGrid *arg1 = (wxGrid *) 0 ;
16402 int arg2 ;
16403 int arg3 ;
16404 wxColour *arg4 = 0 ;
16405 void *argp1 = 0 ;
16406 int res1 = 0 ;
16407 int val2 ;
16408 int ecode2 = 0 ;
16409 int val3 ;
16410 int ecode3 = 0 ;
16411 wxColour temp4 ;
16412 PyObject * obj0 = 0 ;
16413 PyObject * obj1 = 0 ;
16414 PyObject * obj2 = 0 ;
16415 PyObject * obj3 = 0 ;
16416 char * kwnames[] = {
16417 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16418 };
16419
16420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16422 if (!SWIG_IsOK(res1)) {
16423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16424 }
16425 arg1 = reinterpret_cast< wxGrid * >(argp1);
16426 ecode2 = SWIG_AsVal_int(obj1, &val2);
16427 if (!SWIG_IsOK(ecode2)) {
16428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16429 }
16430 arg2 = static_cast< int >(val2);
16431 ecode3 = SWIG_AsVal_int(obj2, &val3);
16432 if (!SWIG_IsOK(ecode3)) {
16433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16434 }
16435 arg3 = static_cast< int >(val3);
16436 {
16437 arg4 = &temp4;
16438 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16439 }
16440 {
16441 PyThreadState* __tstate = wxPyBeginAllowThreads();
16442 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16443 wxPyEndAllowThreads(__tstate);
16444 if (PyErr_Occurred()) SWIG_fail;
16445 }
16446 resultobj = SWIG_Py_Void();
16447 return resultobj;
16448 fail:
16449 return NULL;
16450 }
16451
16452
16453 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj = 0;
16455 wxGrid *arg1 = (wxGrid *) 0 ;
16456 wxFont *arg2 = 0 ;
16457 void *argp1 = 0 ;
16458 int res1 = 0 ;
16459 void *argp2 = 0 ;
16460 int res2 = 0 ;
16461 PyObject * obj0 = 0 ;
16462 PyObject * obj1 = 0 ;
16463 char * kwnames[] = {
16464 (char *) "self",(char *)"arg2", NULL
16465 };
16466
16467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16469 if (!SWIG_IsOK(res1)) {
16470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16471 }
16472 arg1 = reinterpret_cast< wxGrid * >(argp1);
16473 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16474 if (!SWIG_IsOK(res2)) {
16475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16476 }
16477 if (!argp2) {
16478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16479 }
16480 arg2 = reinterpret_cast< wxFont * >(argp2);
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 resultobj = SWIG_Py_Void();
16488 return resultobj;
16489 fail:
16490 return NULL;
16491 }
16492
16493
16494 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16495 PyObject *resultobj = 0;
16496 wxGrid *arg1 = (wxGrid *) 0 ;
16497 int arg2 ;
16498 int arg3 ;
16499 wxFont *arg4 = 0 ;
16500 void *argp1 = 0 ;
16501 int res1 = 0 ;
16502 int val2 ;
16503 int ecode2 = 0 ;
16504 int val3 ;
16505 int ecode3 = 0 ;
16506 void *argp4 = 0 ;
16507 int res4 = 0 ;
16508 PyObject * obj0 = 0 ;
16509 PyObject * obj1 = 0 ;
16510 PyObject * obj2 = 0 ;
16511 PyObject * obj3 = 0 ;
16512 char * kwnames[] = {
16513 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16514 };
16515
16516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16518 if (!SWIG_IsOK(res1)) {
16519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16520 }
16521 arg1 = reinterpret_cast< wxGrid * >(argp1);
16522 ecode2 = SWIG_AsVal_int(obj1, &val2);
16523 if (!SWIG_IsOK(ecode2)) {
16524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16525 }
16526 arg2 = static_cast< int >(val2);
16527 ecode3 = SWIG_AsVal_int(obj2, &val3);
16528 if (!SWIG_IsOK(ecode3)) {
16529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16530 }
16531 arg3 = static_cast< int >(val3);
16532 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16533 if (!SWIG_IsOK(res4)) {
16534 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16535 }
16536 if (!argp4) {
16537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16538 }
16539 arg4 = reinterpret_cast< wxFont * >(argp4);
16540 {
16541 PyThreadState* __tstate = wxPyBeginAllowThreads();
16542 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 resultobj = SWIG_Py_Void();
16547 return resultobj;
16548 fail:
16549 return NULL;
16550 }
16551
16552
16553 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16554 PyObject *resultobj = 0;
16555 wxGrid *arg1 = (wxGrid *) 0 ;
16556 int arg2 ;
16557 int arg3 ;
16558 void *argp1 = 0 ;
16559 int res1 = 0 ;
16560 int val2 ;
16561 int ecode2 = 0 ;
16562 int val3 ;
16563 int ecode3 = 0 ;
16564 PyObject * obj0 = 0 ;
16565 PyObject * obj1 = 0 ;
16566 PyObject * obj2 = 0 ;
16567 char * kwnames[] = {
16568 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16569 };
16570
16571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) 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_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16575 }
16576 arg1 = reinterpret_cast< wxGrid * >(argp1);
16577 ecode2 = SWIG_AsVal_int(obj1, &val2);
16578 if (!SWIG_IsOK(ecode2)) {
16579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16580 }
16581 arg2 = static_cast< int >(val2);
16582 ecode3 = SWIG_AsVal_int(obj2, &val3);
16583 if (!SWIG_IsOK(ecode3)) {
16584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16585 }
16586 arg3 = static_cast< int >(val3);
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 resultobj = SWIG_Py_Void();
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16601 PyObject *resultobj = 0;
16602 wxGrid *arg1 = (wxGrid *) 0 ;
16603 int arg2 ;
16604 int arg3 ;
16605 int arg4 ;
16606 int arg5 ;
16607 void *argp1 = 0 ;
16608 int res1 = 0 ;
16609 int val2 ;
16610 int ecode2 = 0 ;
16611 int val3 ;
16612 int ecode3 = 0 ;
16613 int val4 ;
16614 int ecode4 = 0 ;
16615 int val5 ;
16616 int ecode5 = 0 ;
16617 PyObject * obj0 = 0 ;
16618 PyObject * obj1 = 0 ;
16619 PyObject * obj2 = 0 ;
16620 PyObject * obj3 = 0 ;
16621 PyObject * obj4 = 0 ;
16622 char * kwnames[] = {
16623 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16624 };
16625
16626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16630 }
16631 arg1 = reinterpret_cast< wxGrid * >(argp1);
16632 ecode2 = SWIG_AsVal_int(obj1, &val2);
16633 if (!SWIG_IsOK(ecode2)) {
16634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16635 }
16636 arg2 = static_cast< int >(val2);
16637 ecode3 = SWIG_AsVal_int(obj2, &val3);
16638 if (!SWIG_IsOK(ecode3)) {
16639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16640 }
16641 arg3 = static_cast< int >(val3);
16642 ecode4 = SWIG_AsVal_int(obj3, &val4);
16643 if (!SWIG_IsOK(ecode4)) {
16644 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16645 }
16646 arg4 = static_cast< int >(val4);
16647 ecode5 = SWIG_AsVal_int(obj4, &val5);
16648 if (!SWIG_IsOK(ecode5)) {
16649 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16650 }
16651 arg5 = static_cast< int >(val5);
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 resultobj = SWIG_Py_Void();
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16666 PyObject *resultobj = 0;
16667 wxGrid *arg1 = (wxGrid *) 0 ;
16668 bool arg2 ;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 bool val2 ;
16672 int ecode2 = 0 ;
16673 PyObject * obj0 = 0 ;
16674 PyObject * obj1 = 0 ;
16675 char * kwnames[] = {
16676 (char *) "self",(char *) "allow", NULL
16677 };
16678
16679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16681 if (!SWIG_IsOK(res1)) {
16682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16683 }
16684 arg1 = reinterpret_cast< wxGrid * >(argp1);
16685 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16686 if (!SWIG_IsOK(ecode2)) {
16687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16688 }
16689 arg2 = static_cast< bool >(val2);
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 (arg1)->SetDefaultCellOverflow(arg2);
16693 wxPyEndAllowThreads(__tstate);
16694 if (PyErr_Occurred()) SWIG_fail;
16695 }
16696 resultobj = SWIG_Py_Void();
16697 return resultobj;
16698 fail:
16699 return NULL;
16700 }
16701
16702
16703 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16704 PyObject *resultobj = 0;
16705 wxGrid *arg1 = (wxGrid *) 0 ;
16706 int arg2 ;
16707 int arg3 ;
16708 bool arg4 ;
16709 void *argp1 = 0 ;
16710 int res1 = 0 ;
16711 int val2 ;
16712 int ecode2 = 0 ;
16713 int val3 ;
16714 int ecode3 = 0 ;
16715 bool val4 ;
16716 int ecode4 = 0 ;
16717 PyObject * obj0 = 0 ;
16718 PyObject * obj1 = 0 ;
16719 PyObject * obj2 = 0 ;
16720 PyObject * obj3 = 0 ;
16721 char * kwnames[] = {
16722 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16723 };
16724
16725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16727 if (!SWIG_IsOK(res1)) {
16728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16729 }
16730 arg1 = reinterpret_cast< wxGrid * >(argp1);
16731 ecode2 = SWIG_AsVal_int(obj1, &val2);
16732 if (!SWIG_IsOK(ecode2)) {
16733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16734 }
16735 arg2 = static_cast< int >(val2);
16736 ecode3 = SWIG_AsVal_int(obj2, &val3);
16737 if (!SWIG_IsOK(ecode3)) {
16738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16739 }
16740 arg3 = static_cast< int >(val3);
16741 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16742 if (!SWIG_IsOK(ecode4)) {
16743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16744 }
16745 arg4 = static_cast< bool >(val4);
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16749 wxPyEndAllowThreads(__tstate);
16750 if (PyErr_Occurred()) SWIG_fail;
16751 }
16752 resultobj = SWIG_Py_Void();
16753 return resultobj;
16754 fail:
16755 return NULL;
16756 }
16757
16758
16759 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16760 PyObject *resultobj = 0;
16761 wxGrid *arg1 = (wxGrid *) 0 ;
16762 int arg2 ;
16763 int arg3 ;
16764 int arg4 ;
16765 int arg5 ;
16766 void *argp1 = 0 ;
16767 int res1 = 0 ;
16768 int val2 ;
16769 int ecode2 = 0 ;
16770 int val3 ;
16771 int ecode3 = 0 ;
16772 int val4 ;
16773 int ecode4 = 0 ;
16774 int val5 ;
16775 int ecode5 = 0 ;
16776 PyObject * obj0 = 0 ;
16777 PyObject * obj1 = 0 ;
16778 PyObject * obj2 = 0 ;
16779 PyObject * obj3 = 0 ;
16780 PyObject * obj4 = 0 ;
16781 char * kwnames[] = {
16782 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16783 };
16784
16785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16787 if (!SWIG_IsOK(res1)) {
16788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16789 }
16790 arg1 = reinterpret_cast< wxGrid * >(argp1);
16791 ecode2 = SWIG_AsVal_int(obj1, &val2);
16792 if (!SWIG_IsOK(ecode2)) {
16793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16794 }
16795 arg2 = static_cast< int >(val2);
16796 ecode3 = SWIG_AsVal_int(obj2, &val3);
16797 if (!SWIG_IsOK(ecode3)) {
16798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16799 }
16800 arg3 = static_cast< int >(val3);
16801 ecode4 = SWIG_AsVal_int(obj3, &val4);
16802 if (!SWIG_IsOK(ecode4)) {
16803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16804 }
16805 arg4 = static_cast< int >(val4);
16806 ecode5 = SWIG_AsVal_int(obj4, &val5);
16807 if (!SWIG_IsOK(ecode5)) {
16808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16809 }
16810 arg5 = static_cast< int >(val5);
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 resultobj = SWIG_Py_Void();
16818 return resultobj;
16819 fail:
16820 return NULL;
16821 }
16822
16823
16824 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16825 PyObject *resultobj = 0;
16826 wxGrid *arg1 = (wxGrid *) 0 ;
16827 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16828 void *argp1 = 0 ;
16829 int res1 = 0 ;
16830 void *argp2 = 0 ;
16831 int res2 = 0 ;
16832 PyObject * obj0 = 0 ;
16833 PyObject * obj1 = 0 ;
16834 char * kwnames[] = {
16835 (char *) "self",(char *) "renderer", NULL
16836 };
16837
16838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16840 if (!SWIG_IsOK(res1)) {
16841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16842 }
16843 arg1 = reinterpret_cast< wxGrid * >(argp1);
16844 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16845 if (!SWIG_IsOK(res2)) {
16846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16847 }
16848 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16849 {
16850 PyThreadState* __tstate = wxPyBeginAllowThreads();
16851 (arg1)->SetDefaultRenderer(arg2);
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 resultobj = SWIG_Py_Void();
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj = 0;
16864 wxGrid *arg1 = (wxGrid *) 0 ;
16865 int arg2 ;
16866 int arg3 ;
16867 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16868 void *argp1 = 0 ;
16869 int res1 = 0 ;
16870 int val2 ;
16871 int ecode2 = 0 ;
16872 int val3 ;
16873 int ecode3 = 0 ;
16874 void *argp4 = 0 ;
16875 int res4 = 0 ;
16876 PyObject * obj0 = 0 ;
16877 PyObject * obj1 = 0 ;
16878 PyObject * obj2 = 0 ;
16879 PyObject * obj3 = 0 ;
16880 char * kwnames[] = {
16881 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16882 };
16883
16884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16886 if (!SWIG_IsOK(res1)) {
16887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16888 }
16889 arg1 = reinterpret_cast< wxGrid * >(argp1);
16890 ecode2 = SWIG_AsVal_int(obj1, &val2);
16891 if (!SWIG_IsOK(ecode2)) {
16892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16893 }
16894 arg2 = static_cast< int >(val2);
16895 ecode3 = SWIG_AsVal_int(obj2, &val3);
16896 if (!SWIG_IsOK(ecode3)) {
16897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16898 }
16899 arg3 = static_cast< int >(val3);
16900 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16901 if (!SWIG_IsOK(res4)) {
16902 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16903 }
16904 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 resultobj = SWIG_Py_Void();
16912 return resultobj;
16913 fail:
16914 return NULL;
16915 }
16916
16917
16918 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16919 PyObject *resultobj = 0;
16920 wxGrid *arg1 = (wxGrid *) 0 ;
16921 wxGridCellRenderer *result = 0 ;
16922 void *argp1 = 0 ;
16923 int res1 = 0 ;
16924 PyObject *swig_obj[1] ;
16925
16926 if (!args) SWIG_fail;
16927 swig_obj[0] = args;
16928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16929 if (!SWIG_IsOK(res1)) {
16930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16931 }
16932 arg1 = reinterpret_cast< wxGrid * >(argp1);
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 {
16940 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16941 }
16942 return resultobj;
16943 fail:
16944 return NULL;
16945 }
16946
16947
16948 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16949 PyObject *resultobj = 0;
16950 wxGrid *arg1 = (wxGrid *) 0 ;
16951 int arg2 ;
16952 int arg3 ;
16953 wxGridCellRenderer *result = 0 ;
16954 void *argp1 = 0 ;
16955 int res1 = 0 ;
16956 int val2 ;
16957 int ecode2 = 0 ;
16958 int val3 ;
16959 int ecode3 = 0 ;
16960 PyObject * obj0 = 0 ;
16961 PyObject * obj1 = 0 ;
16962 PyObject * obj2 = 0 ;
16963 char * kwnames[] = {
16964 (char *) "self",(char *) "row",(char *) "col", NULL
16965 };
16966
16967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16969 if (!SWIG_IsOK(res1)) {
16970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16971 }
16972 arg1 = reinterpret_cast< wxGrid * >(argp1);
16973 ecode2 = SWIG_AsVal_int(obj1, &val2);
16974 if (!SWIG_IsOK(ecode2)) {
16975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16976 }
16977 arg2 = static_cast< int >(val2);
16978 ecode3 = SWIG_AsVal_int(obj2, &val3);
16979 if (!SWIG_IsOK(ecode3)) {
16980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16981 }
16982 arg3 = static_cast< int >(val3);
16983 {
16984 PyThreadState* __tstate = wxPyBeginAllowThreads();
16985 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16986 wxPyEndAllowThreads(__tstate);
16987 if (PyErr_Occurred()) SWIG_fail;
16988 }
16989 {
16990 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16991 }
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16999 PyObject *resultobj = 0;
17000 wxGrid *arg1 = (wxGrid *) 0 ;
17001 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17002 void *argp1 = 0 ;
17003 int res1 = 0 ;
17004 void *argp2 = 0 ;
17005 int res2 = 0 ;
17006 PyObject * obj0 = 0 ;
17007 PyObject * obj1 = 0 ;
17008 char * kwnames[] = {
17009 (char *) "self",(char *) "editor", NULL
17010 };
17011
17012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17014 if (!SWIG_IsOK(res1)) {
17015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17016 }
17017 arg1 = reinterpret_cast< wxGrid * >(argp1);
17018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17019 if (!SWIG_IsOK(res2)) {
17020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17021 }
17022 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17023 {
17024 PyThreadState* __tstate = wxPyBeginAllowThreads();
17025 (arg1)->SetDefaultEditor(arg2);
17026 wxPyEndAllowThreads(__tstate);
17027 if (PyErr_Occurred()) SWIG_fail;
17028 }
17029 resultobj = SWIG_Py_Void();
17030 return resultobj;
17031 fail:
17032 return NULL;
17033 }
17034
17035
17036 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17037 PyObject *resultobj = 0;
17038 wxGrid *arg1 = (wxGrid *) 0 ;
17039 int arg2 ;
17040 int arg3 ;
17041 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17042 void *argp1 = 0 ;
17043 int res1 = 0 ;
17044 int val2 ;
17045 int ecode2 = 0 ;
17046 int val3 ;
17047 int ecode3 = 0 ;
17048 void *argp4 = 0 ;
17049 int res4 = 0 ;
17050 PyObject * obj0 = 0 ;
17051 PyObject * obj1 = 0 ;
17052 PyObject * obj2 = 0 ;
17053 PyObject * obj3 = 0 ;
17054 char * kwnames[] = {
17055 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17056 };
17057
17058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17060 if (!SWIG_IsOK(res1)) {
17061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17062 }
17063 arg1 = reinterpret_cast< wxGrid * >(argp1);
17064 ecode2 = SWIG_AsVal_int(obj1, &val2);
17065 if (!SWIG_IsOK(ecode2)) {
17066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17067 }
17068 arg2 = static_cast< int >(val2);
17069 ecode3 = SWIG_AsVal_int(obj2, &val3);
17070 if (!SWIG_IsOK(ecode3)) {
17071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17072 }
17073 arg3 = static_cast< int >(val3);
17074 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17075 if (!SWIG_IsOK(res4)) {
17076 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17077 }
17078 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 (arg1)->SetCellEditor(arg2,arg3,arg4);
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 resultobj = SWIG_Py_Void();
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17093 PyObject *resultobj = 0;
17094 wxGrid *arg1 = (wxGrid *) 0 ;
17095 wxGridCellEditor *result = 0 ;
17096 void *argp1 = 0 ;
17097 int res1 = 0 ;
17098 PyObject *swig_obj[1] ;
17099
17100 if (!args) SWIG_fail;
17101 swig_obj[0] = args;
17102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17103 if (!SWIG_IsOK(res1)) {
17104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17105 }
17106 arg1 = reinterpret_cast< wxGrid * >(argp1);
17107 {
17108 PyThreadState* __tstate = wxPyBeginAllowThreads();
17109 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17110 wxPyEndAllowThreads(__tstate);
17111 if (PyErr_Occurred()) SWIG_fail;
17112 }
17113 {
17114 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17115 }
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17123 PyObject *resultobj = 0;
17124 wxGrid *arg1 = (wxGrid *) 0 ;
17125 int arg2 ;
17126 int arg3 ;
17127 wxGridCellEditor *result = 0 ;
17128 void *argp1 = 0 ;
17129 int res1 = 0 ;
17130 int val2 ;
17131 int ecode2 = 0 ;
17132 int val3 ;
17133 int ecode3 = 0 ;
17134 PyObject * obj0 = 0 ;
17135 PyObject * obj1 = 0 ;
17136 PyObject * obj2 = 0 ;
17137 char * kwnames[] = {
17138 (char *) "self",(char *) "row",(char *) "col", NULL
17139 };
17140
17141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17143 if (!SWIG_IsOK(res1)) {
17144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17145 }
17146 arg1 = reinterpret_cast< wxGrid * >(argp1);
17147 ecode2 = SWIG_AsVal_int(obj1, &val2);
17148 if (!SWIG_IsOK(ecode2)) {
17149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17150 }
17151 arg2 = static_cast< int >(val2);
17152 ecode3 = SWIG_AsVal_int(obj2, &val3);
17153 if (!SWIG_IsOK(ecode3)) {
17154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17155 }
17156 arg3 = static_cast< int >(val3);
17157 {
17158 PyThreadState* __tstate = wxPyBeginAllowThreads();
17159 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17160 wxPyEndAllowThreads(__tstate);
17161 if (PyErr_Occurred()) SWIG_fail;
17162 }
17163 {
17164 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17165 }
17166 return resultobj;
17167 fail:
17168 return NULL;
17169 }
17170
17171
17172 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17173 PyObject *resultobj = 0;
17174 wxGrid *arg1 = (wxGrid *) 0 ;
17175 int arg2 ;
17176 int arg3 ;
17177 wxString result;
17178 void *argp1 = 0 ;
17179 int res1 = 0 ;
17180 int val2 ;
17181 int ecode2 = 0 ;
17182 int val3 ;
17183 int ecode3 = 0 ;
17184 PyObject * obj0 = 0 ;
17185 PyObject * obj1 = 0 ;
17186 PyObject * obj2 = 0 ;
17187 char * kwnames[] = {
17188 (char *) "self",(char *) "row",(char *) "col", NULL
17189 };
17190
17191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17193 if (!SWIG_IsOK(res1)) {
17194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17195 }
17196 arg1 = reinterpret_cast< wxGrid * >(argp1);
17197 ecode2 = SWIG_AsVal_int(obj1, &val2);
17198 if (!SWIG_IsOK(ecode2)) {
17199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17200 }
17201 arg2 = static_cast< int >(val2);
17202 ecode3 = SWIG_AsVal_int(obj2, &val3);
17203 if (!SWIG_IsOK(ecode3)) {
17204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17205 }
17206 arg3 = static_cast< int >(val3);
17207 {
17208 PyThreadState* __tstate = wxPyBeginAllowThreads();
17209 result = (arg1)->GetCellValue(arg2,arg3);
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 {
17214 #if wxUSE_UNICODE
17215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17216 #else
17217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17218 #endif
17219 }
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj = 0;
17228 wxGrid *arg1 = (wxGrid *) 0 ;
17229 int arg2 ;
17230 int arg3 ;
17231 wxString *arg4 = 0 ;
17232 void *argp1 = 0 ;
17233 int res1 = 0 ;
17234 int val2 ;
17235 int ecode2 = 0 ;
17236 int val3 ;
17237 int ecode3 = 0 ;
17238 bool temp4 = false ;
17239 PyObject * obj0 = 0 ;
17240 PyObject * obj1 = 0 ;
17241 PyObject * obj2 = 0 ;
17242 PyObject * obj3 = 0 ;
17243 char * kwnames[] = {
17244 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17245 };
17246
17247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17249 if (!SWIG_IsOK(res1)) {
17250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17251 }
17252 arg1 = reinterpret_cast< wxGrid * >(argp1);
17253 ecode2 = SWIG_AsVal_int(obj1, &val2);
17254 if (!SWIG_IsOK(ecode2)) {
17255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17256 }
17257 arg2 = static_cast< int >(val2);
17258 ecode3 = SWIG_AsVal_int(obj2, &val3);
17259 if (!SWIG_IsOK(ecode3)) {
17260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17261 }
17262 arg3 = static_cast< int >(val3);
17263 {
17264 arg4 = wxString_in_helper(obj3);
17265 if (arg4 == NULL) SWIG_fail;
17266 temp4 = true;
17267 }
17268 {
17269 PyThreadState* __tstate = wxPyBeginAllowThreads();
17270 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17271 wxPyEndAllowThreads(__tstate);
17272 if (PyErr_Occurred()) SWIG_fail;
17273 }
17274 resultobj = SWIG_Py_Void();
17275 {
17276 if (temp4)
17277 delete arg4;
17278 }
17279 return resultobj;
17280 fail:
17281 {
17282 if (temp4)
17283 delete arg4;
17284 }
17285 return NULL;
17286 }
17287
17288
17289 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17290 PyObject *resultobj = 0;
17291 wxGrid *arg1 = (wxGrid *) 0 ;
17292 int arg2 ;
17293 int arg3 ;
17294 bool result;
17295 void *argp1 = 0 ;
17296 int res1 = 0 ;
17297 int val2 ;
17298 int ecode2 = 0 ;
17299 int val3 ;
17300 int ecode3 = 0 ;
17301 PyObject * obj0 = 0 ;
17302 PyObject * obj1 = 0 ;
17303 PyObject * obj2 = 0 ;
17304 char * kwnames[] = {
17305 (char *) "self",(char *) "row",(char *) "col", NULL
17306 };
17307
17308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17310 if (!SWIG_IsOK(res1)) {
17311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17312 }
17313 arg1 = reinterpret_cast< wxGrid * >(argp1);
17314 ecode2 = SWIG_AsVal_int(obj1, &val2);
17315 if (!SWIG_IsOK(ecode2)) {
17316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17317 }
17318 arg2 = static_cast< int >(val2);
17319 ecode3 = SWIG_AsVal_int(obj2, &val3);
17320 if (!SWIG_IsOK(ecode3)) {
17321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17322 }
17323 arg3 = static_cast< int >(val3);
17324 {
17325 PyThreadState* __tstate = wxPyBeginAllowThreads();
17326 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17327 wxPyEndAllowThreads(__tstate);
17328 if (PyErr_Occurred()) SWIG_fail;
17329 }
17330 {
17331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17332 }
17333 return resultobj;
17334 fail:
17335 return NULL;
17336 }
17337
17338
17339 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17340 PyObject *resultobj = 0;
17341 wxGrid *arg1 = (wxGrid *) 0 ;
17342 int arg2 ;
17343 int arg3 ;
17344 bool arg4 = (bool) true ;
17345 void *argp1 = 0 ;
17346 int res1 = 0 ;
17347 int val2 ;
17348 int ecode2 = 0 ;
17349 int val3 ;
17350 int ecode3 = 0 ;
17351 bool val4 ;
17352 int ecode4 = 0 ;
17353 PyObject * obj0 = 0 ;
17354 PyObject * obj1 = 0 ;
17355 PyObject * obj2 = 0 ;
17356 PyObject * obj3 = 0 ;
17357 char * kwnames[] = {
17358 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17359 };
17360
17361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17363 if (!SWIG_IsOK(res1)) {
17364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17365 }
17366 arg1 = reinterpret_cast< wxGrid * >(argp1);
17367 ecode2 = SWIG_AsVal_int(obj1, &val2);
17368 if (!SWIG_IsOK(ecode2)) {
17369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17370 }
17371 arg2 = static_cast< int >(val2);
17372 ecode3 = SWIG_AsVal_int(obj2, &val3);
17373 if (!SWIG_IsOK(ecode3)) {
17374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17375 }
17376 arg3 = static_cast< int >(val3);
17377 if (obj3) {
17378 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17379 if (!SWIG_IsOK(ecode4)) {
17380 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17381 }
17382 arg4 = static_cast< bool >(val4);
17383 }
17384 {
17385 PyThreadState* __tstate = wxPyBeginAllowThreads();
17386 (arg1)->SetReadOnly(arg2,arg3,arg4);
17387 wxPyEndAllowThreads(__tstate);
17388 if (PyErr_Occurred()) SWIG_fail;
17389 }
17390 resultobj = SWIG_Py_Void();
17391 return resultobj;
17392 fail:
17393 return NULL;
17394 }
17395
17396
17397 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17398 PyObject *resultobj = 0;
17399 wxGrid *arg1 = (wxGrid *) 0 ;
17400 int arg2 ;
17401 bool arg3 = (bool) false ;
17402 void *argp1 = 0 ;
17403 int res1 = 0 ;
17404 int val2 ;
17405 int ecode2 = 0 ;
17406 bool val3 ;
17407 int ecode3 = 0 ;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 PyObject * obj2 = 0 ;
17411 char * kwnames[] = {
17412 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17413 };
17414
17415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17417 if (!SWIG_IsOK(res1)) {
17418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17419 }
17420 arg1 = reinterpret_cast< wxGrid * >(argp1);
17421 ecode2 = SWIG_AsVal_int(obj1, &val2);
17422 if (!SWIG_IsOK(ecode2)) {
17423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17424 }
17425 arg2 = static_cast< int >(val2);
17426 if (obj2) {
17427 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17428 if (!SWIG_IsOK(ecode3)) {
17429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17430 }
17431 arg3 = static_cast< bool >(val3);
17432 }
17433 {
17434 PyThreadState* __tstate = wxPyBeginAllowThreads();
17435 (arg1)->SelectRow(arg2,arg3);
17436 wxPyEndAllowThreads(__tstate);
17437 if (PyErr_Occurred()) SWIG_fail;
17438 }
17439 resultobj = SWIG_Py_Void();
17440 return resultobj;
17441 fail:
17442 return NULL;
17443 }
17444
17445
17446 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17447 PyObject *resultobj = 0;
17448 wxGrid *arg1 = (wxGrid *) 0 ;
17449 int arg2 ;
17450 bool arg3 = (bool) false ;
17451 void *argp1 = 0 ;
17452 int res1 = 0 ;
17453 int val2 ;
17454 int ecode2 = 0 ;
17455 bool val3 ;
17456 int ecode3 = 0 ;
17457 PyObject * obj0 = 0 ;
17458 PyObject * obj1 = 0 ;
17459 PyObject * obj2 = 0 ;
17460 char * kwnames[] = {
17461 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17462 };
17463
17464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17466 if (!SWIG_IsOK(res1)) {
17467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17468 }
17469 arg1 = reinterpret_cast< wxGrid * >(argp1);
17470 ecode2 = SWIG_AsVal_int(obj1, &val2);
17471 if (!SWIG_IsOK(ecode2)) {
17472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17473 }
17474 arg2 = static_cast< int >(val2);
17475 if (obj2) {
17476 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17477 if (!SWIG_IsOK(ecode3)) {
17478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17479 }
17480 arg3 = static_cast< bool >(val3);
17481 }
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 (arg1)->SelectCol(arg2,arg3);
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 resultobj = SWIG_Py_Void();
17489 return resultobj;
17490 fail:
17491 return NULL;
17492 }
17493
17494
17495 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17496 PyObject *resultobj = 0;
17497 wxGrid *arg1 = (wxGrid *) 0 ;
17498 int arg2 ;
17499 int arg3 ;
17500 int arg4 ;
17501 int arg5 ;
17502 bool arg6 = (bool) false ;
17503 void *argp1 = 0 ;
17504 int res1 = 0 ;
17505 int val2 ;
17506 int ecode2 = 0 ;
17507 int val3 ;
17508 int ecode3 = 0 ;
17509 int val4 ;
17510 int ecode4 = 0 ;
17511 int val5 ;
17512 int ecode5 = 0 ;
17513 bool val6 ;
17514 int ecode6 = 0 ;
17515 PyObject * obj0 = 0 ;
17516 PyObject * obj1 = 0 ;
17517 PyObject * obj2 = 0 ;
17518 PyObject * obj3 = 0 ;
17519 PyObject * obj4 = 0 ;
17520 PyObject * obj5 = 0 ;
17521 char * kwnames[] = {
17522 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17523 };
17524
17525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17527 if (!SWIG_IsOK(res1)) {
17528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17529 }
17530 arg1 = reinterpret_cast< wxGrid * >(argp1);
17531 ecode2 = SWIG_AsVal_int(obj1, &val2);
17532 if (!SWIG_IsOK(ecode2)) {
17533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17534 }
17535 arg2 = static_cast< int >(val2);
17536 ecode3 = SWIG_AsVal_int(obj2, &val3);
17537 if (!SWIG_IsOK(ecode3)) {
17538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17539 }
17540 arg3 = static_cast< int >(val3);
17541 ecode4 = SWIG_AsVal_int(obj3, &val4);
17542 if (!SWIG_IsOK(ecode4)) {
17543 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17544 }
17545 arg4 = static_cast< int >(val4);
17546 ecode5 = SWIG_AsVal_int(obj4, &val5);
17547 if (!SWIG_IsOK(ecode5)) {
17548 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17549 }
17550 arg5 = static_cast< int >(val5);
17551 if (obj5) {
17552 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17553 if (!SWIG_IsOK(ecode6)) {
17554 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17555 }
17556 arg6 = static_cast< bool >(val6);
17557 }
17558 {
17559 PyThreadState* __tstate = wxPyBeginAllowThreads();
17560 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17561 wxPyEndAllowThreads(__tstate);
17562 if (PyErr_Occurred()) SWIG_fail;
17563 }
17564 resultobj = SWIG_Py_Void();
17565 return resultobj;
17566 fail:
17567 return NULL;
17568 }
17569
17570
17571 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17572 PyObject *resultobj = 0;
17573 wxGrid *arg1 = (wxGrid *) 0 ;
17574 void *argp1 = 0 ;
17575 int res1 = 0 ;
17576 PyObject *swig_obj[1] ;
17577
17578 if (!args) SWIG_fail;
17579 swig_obj[0] = args;
17580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17581 if (!SWIG_IsOK(res1)) {
17582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17583 }
17584 arg1 = reinterpret_cast< wxGrid * >(argp1);
17585 {
17586 PyThreadState* __tstate = wxPyBeginAllowThreads();
17587 (arg1)->SelectAll();
17588 wxPyEndAllowThreads(__tstate);
17589 if (PyErr_Occurred()) SWIG_fail;
17590 }
17591 resultobj = SWIG_Py_Void();
17592 return resultobj;
17593 fail:
17594 return NULL;
17595 }
17596
17597
17598 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17599 PyObject *resultobj = 0;
17600 wxGrid *arg1 = (wxGrid *) 0 ;
17601 bool result;
17602 void *argp1 = 0 ;
17603 int res1 = 0 ;
17604 PyObject *swig_obj[1] ;
17605
17606 if (!args) SWIG_fail;
17607 swig_obj[0] = args;
17608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17609 if (!SWIG_IsOK(res1)) {
17610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17611 }
17612 arg1 = reinterpret_cast< wxGrid * >(argp1);
17613 {
17614 PyThreadState* __tstate = wxPyBeginAllowThreads();
17615 result = (bool)(arg1)->IsSelection();
17616 wxPyEndAllowThreads(__tstate);
17617 if (PyErr_Occurred()) SWIG_fail;
17618 }
17619 {
17620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17621 }
17622 return resultobj;
17623 fail:
17624 return NULL;
17625 }
17626
17627
17628 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17629 PyObject *resultobj = 0;
17630 wxGrid *arg1 = (wxGrid *) 0 ;
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_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17640 }
17641 arg1 = reinterpret_cast< wxGrid * >(argp1);
17642 {
17643 PyThreadState* __tstate = wxPyBeginAllowThreads();
17644 (arg1)->ClearSelection();
17645 wxPyEndAllowThreads(__tstate);
17646 if (PyErr_Occurred()) SWIG_fail;
17647 }
17648 resultobj = SWIG_Py_Void();
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj = 0;
17657 wxGrid *arg1 = (wxGrid *) 0 ;
17658 int arg2 ;
17659 int arg3 ;
17660 bool result;
17661 void *argp1 = 0 ;
17662 int res1 = 0 ;
17663 int val2 ;
17664 int ecode2 = 0 ;
17665 int val3 ;
17666 int ecode3 = 0 ;
17667 PyObject * obj0 = 0 ;
17668 PyObject * obj1 = 0 ;
17669 PyObject * obj2 = 0 ;
17670 char * kwnames[] = {
17671 (char *) "self",(char *) "row",(char *) "col", NULL
17672 };
17673
17674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17676 if (!SWIG_IsOK(res1)) {
17677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17678 }
17679 arg1 = reinterpret_cast< wxGrid * >(argp1);
17680 ecode2 = SWIG_AsVal_int(obj1, &val2);
17681 if (!SWIG_IsOK(ecode2)) {
17682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17683 }
17684 arg2 = static_cast< int >(val2);
17685 ecode3 = SWIG_AsVal_int(obj2, &val3);
17686 if (!SWIG_IsOK(ecode3)) {
17687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17688 }
17689 arg3 = static_cast< int >(val3);
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 {
17697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17698 }
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17706 PyObject *resultobj = 0;
17707 wxGrid *arg1 = (wxGrid *) 0 ;
17708 wxGridCellCoordsArray result;
17709 void *argp1 = 0 ;
17710 int res1 = 0 ;
17711 PyObject *swig_obj[1] ;
17712
17713 if (!args) SWIG_fail;
17714 swig_obj[0] = args;
17715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17716 if (!SWIG_IsOK(res1)) {
17717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17718 }
17719 arg1 = reinterpret_cast< wxGrid * >(argp1);
17720 {
17721 PyThreadState* __tstate = wxPyBeginAllowThreads();
17722 result = ((wxGrid const *)arg1)->GetSelectedCells();
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 {
17727 resultobj = wxGridCellCoordsArray_helper(result);
17728 }
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17736 PyObject *resultobj = 0;
17737 wxGrid *arg1 = (wxGrid *) 0 ;
17738 wxGridCellCoordsArray result;
17739 void *argp1 = 0 ;
17740 int res1 = 0 ;
17741 PyObject *swig_obj[1] ;
17742
17743 if (!args) SWIG_fail;
17744 swig_obj[0] = args;
17745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17746 if (!SWIG_IsOK(res1)) {
17747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17748 }
17749 arg1 = reinterpret_cast< wxGrid * >(argp1);
17750 {
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 {
17757 resultobj = wxGridCellCoordsArray_helper(result);
17758 }
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17766 PyObject *resultobj = 0;
17767 wxGrid *arg1 = (wxGrid *) 0 ;
17768 wxGridCellCoordsArray result;
17769 void *argp1 = 0 ;
17770 int res1 = 0 ;
17771 PyObject *swig_obj[1] ;
17772
17773 if (!args) SWIG_fail;
17774 swig_obj[0] = args;
17775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17776 if (!SWIG_IsOK(res1)) {
17777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17778 }
17779 arg1 = reinterpret_cast< wxGrid * >(argp1);
17780 {
17781 PyThreadState* __tstate = wxPyBeginAllowThreads();
17782 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17783 wxPyEndAllowThreads(__tstate);
17784 if (PyErr_Occurred()) SWIG_fail;
17785 }
17786 {
17787 resultobj = wxGridCellCoordsArray_helper(result);
17788 }
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17796 PyObject *resultobj = 0;
17797 wxGrid *arg1 = (wxGrid *) 0 ;
17798 wxArrayInt result;
17799 void *argp1 = 0 ;
17800 int res1 = 0 ;
17801 PyObject *swig_obj[1] ;
17802
17803 if (!args) SWIG_fail;
17804 swig_obj[0] = args;
17805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17806 if (!SWIG_IsOK(res1)) {
17807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17808 }
17809 arg1 = reinterpret_cast< wxGrid * >(argp1);
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 result = ((wxGrid const *)arg1)->GetSelectedRows();
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 {
17817 resultobj = PyList_New(0);
17818 size_t idx;
17819 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17820 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17821 PyList_Append(resultobj, val);
17822 Py_DECREF(val);
17823 }
17824 }
17825 return resultobj;
17826 fail:
17827 return NULL;
17828 }
17829
17830
17831 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17832 PyObject *resultobj = 0;
17833 wxGrid *arg1 = (wxGrid *) 0 ;
17834 wxArrayInt result;
17835 void *argp1 = 0 ;
17836 int res1 = 0 ;
17837 PyObject *swig_obj[1] ;
17838
17839 if (!args) SWIG_fail;
17840 swig_obj[0] = args;
17841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17842 if (!SWIG_IsOK(res1)) {
17843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17844 }
17845 arg1 = reinterpret_cast< wxGrid * >(argp1);
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = ((wxGrid const *)arg1)->GetSelectedCols();
17849 wxPyEndAllowThreads(__tstate);
17850 if (PyErr_Occurred()) SWIG_fail;
17851 }
17852 {
17853 resultobj = PyList_New(0);
17854 size_t idx;
17855 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17856 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17857 PyList_Append(resultobj, val);
17858 Py_DECREF(val);
17859 }
17860 }
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17868 PyObject *resultobj = 0;
17869 wxGrid *arg1 = (wxGrid *) 0 ;
17870 int arg2 ;
17871 void *argp1 = 0 ;
17872 int res1 = 0 ;
17873 int val2 ;
17874 int ecode2 = 0 ;
17875 PyObject * obj0 = 0 ;
17876 PyObject * obj1 = 0 ;
17877 char * kwnames[] = {
17878 (char *) "self",(char *) "row", NULL
17879 };
17880
17881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17883 if (!SWIG_IsOK(res1)) {
17884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17885 }
17886 arg1 = reinterpret_cast< wxGrid * >(argp1);
17887 ecode2 = SWIG_AsVal_int(obj1, &val2);
17888 if (!SWIG_IsOK(ecode2)) {
17889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17890 }
17891 arg2 = static_cast< int >(val2);
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 (arg1)->DeselectRow(arg2);
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 resultobj = SWIG_Py_Void();
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj = 0;
17907 wxGrid *arg1 = (wxGrid *) 0 ;
17908 int arg2 ;
17909 void *argp1 = 0 ;
17910 int res1 = 0 ;
17911 int val2 ;
17912 int ecode2 = 0 ;
17913 PyObject * obj0 = 0 ;
17914 PyObject * obj1 = 0 ;
17915 char * kwnames[] = {
17916 (char *) "self",(char *) "col", NULL
17917 };
17918
17919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17921 if (!SWIG_IsOK(res1)) {
17922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17923 }
17924 arg1 = reinterpret_cast< wxGrid * >(argp1);
17925 ecode2 = SWIG_AsVal_int(obj1, &val2);
17926 if (!SWIG_IsOK(ecode2)) {
17927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17928 }
17929 arg2 = static_cast< int >(val2);
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 (arg1)->DeselectCol(arg2);
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 resultobj = SWIG_Py_Void();
17937 return resultobj;
17938 fail:
17939 return NULL;
17940 }
17941
17942
17943 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17944 PyObject *resultobj = 0;
17945 wxGrid *arg1 = (wxGrid *) 0 ;
17946 int arg2 ;
17947 int arg3 ;
17948 void *argp1 = 0 ;
17949 int res1 = 0 ;
17950 int val2 ;
17951 int ecode2 = 0 ;
17952 int val3 ;
17953 int ecode3 = 0 ;
17954 PyObject * obj0 = 0 ;
17955 PyObject * obj1 = 0 ;
17956 PyObject * obj2 = 0 ;
17957 char * kwnames[] = {
17958 (char *) "self",(char *) "row",(char *) "col", NULL
17959 };
17960
17961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17963 if (!SWIG_IsOK(res1)) {
17964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17965 }
17966 arg1 = reinterpret_cast< wxGrid * >(argp1);
17967 ecode2 = SWIG_AsVal_int(obj1, &val2);
17968 if (!SWIG_IsOK(ecode2)) {
17969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17970 }
17971 arg2 = static_cast< int >(val2);
17972 ecode3 = SWIG_AsVal_int(obj2, &val3);
17973 if (!SWIG_IsOK(ecode3)) {
17974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17975 }
17976 arg3 = static_cast< int >(val3);
17977 {
17978 PyThreadState* __tstate = wxPyBeginAllowThreads();
17979 (arg1)->DeselectCell(arg2,arg3);
17980 wxPyEndAllowThreads(__tstate);
17981 if (PyErr_Occurred()) SWIG_fail;
17982 }
17983 resultobj = SWIG_Py_Void();
17984 return resultobj;
17985 fail:
17986 return NULL;
17987 }
17988
17989
17990 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17991 PyObject *resultobj = 0;
17992 wxGrid *arg1 = (wxGrid *) 0 ;
17993 wxGridCellCoords *arg2 = 0 ;
17994 wxGridCellCoords *arg3 = 0 ;
17995 wxRect result;
17996 void *argp1 = 0 ;
17997 int res1 = 0 ;
17998 wxGridCellCoords temp2 ;
17999 wxGridCellCoords temp3 ;
18000 PyObject * obj0 = 0 ;
18001 PyObject * obj1 = 0 ;
18002 PyObject * obj2 = 0 ;
18003 char * kwnames[] = {
18004 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18005 };
18006
18007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18009 if (!SWIG_IsOK(res1)) {
18010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18011 }
18012 arg1 = reinterpret_cast< wxGrid * >(argp1);
18013 {
18014 arg2 = &temp2;
18015 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18016 }
18017 {
18018 arg3 = &temp3;
18019 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18020 }
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18035 PyObject *resultobj = 0;
18036 wxGrid *arg1 = (wxGrid *) 0 ;
18037 wxColour result;
18038 void *argp1 = 0 ;
18039 int res1 = 0 ;
18040 PyObject *swig_obj[1] ;
18041
18042 if (!args) SWIG_fail;
18043 swig_obj[0] = args;
18044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18045 if (!SWIG_IsOK(res1)) {
18046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18047 }
18048 arg1 = reinterpret_cast< wxGrid * >(argp1);
18049 {
18050 PyThreadState* __tstate = wxPyBeginAllowThreads();
18051 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18052 wxPyEndAllowThreads(__tstate);
18053 if (PyErr_Occurred()) SWIG_fail;
18054 }
18055 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063 PyObject *resultobj = 0;
18064 wxGrid *arg1 = (wxGrid *) 0 ;
18065 wxColour result;
18066 void *argp1 = 0 ;
18067 int res1 = 0 ;
18068 PyObject *swig_obj[1] ;
18069
18070 if (!args) SWIG_fail;
18071 swig_obj[0] = args;
18072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18073 if (!SWIG_IsOK(res1)) {
18074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18075 }
18076 arg1 = reinterpret_cast< wxGrid * >(argp1);
18077 {
18078 PyThreadState* __tstate = wxPyBeginAllowThreads();
18079 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj = 0;
18092 wxGrid *arg1 = (wxGrid *) 0 ;
18093 wxColour *arg2 = 0 ;
18094 void *argp1 = 0 ;
18095 int res1 = 0 ;
18096 wxColour temp2 ;
18097 PyObject * obj0 = 0 ;
18098 PyObject * obj1 = 0 ;
18099 char * kwnames[] = {
18100 (char *) "self",(char *) "c", NULL
18101 };
18102
18103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18105 if (!SWIG_IsOK(res1)) {
18106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18107 }
18108 arg1 = reinterpret_cast< wxGrid * >(argp1);
18109 {
18110 arg2 = &temp2;
18111 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18112 }
18113 {
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 resultobj = SWIG_Py_Void();
18120 return resultobj;
18121 fail:
18122 return NULL;
18123 }
18124
18125
18126 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18127 PyObject *resultobj = 0;
18128 wxGrid *arg1 = (wxGrid *) 0 ;
18129 wxColour *arg2 = 0 ;
18130 void *argp1 = 0 ;
18131 int res1 = 0 ;
18132 wxColour temp2 ;
18133 PyObject * obj0 = 0 ;
18134 PyObject * obj1 = 0 ;
18135 char * kwnames[] = {
18136 (char *) "self",(char *) "c", NULL
18137 };
18138
18139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18141 if (!SWIG_IsOK(res1)) {
18142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18143 }
18144 arg1 = reinterpret_cast< wxGrid * >(argp1);
18145 {
18146 arg2 = &temp2;
18147 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18148 }
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_Py_Void();
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18163 PyObject *resultobj = 0;
18164 wxGrid *arg1 = (wxGrid *) 0 ;
18165 wxString *arg2 = 0 ;
18166 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18167 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18168 void *argp1 = 0 ;
18169 int res1 = 0 ;
18170 bool temp2 = false ;
18171 void *argp3 = 0 ;
18172 int res3 = 0 ;
18173 void *argp4 = 0 ;
18174 int res4 = 0 ;
18175 PyObject * obj0 = 0 ;
18176 PyObject * obj1 = 0 ;
18177 PyObject * obj2 = 0 ;
18178 PyObject * obj3 = 0 ;
18179 char * kwnames[] = {
18180 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18181 };
18182
18183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18185 if (!SWIG_IsOK(res1)) {
18186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18187 }
18188 arg1 = reinterpret_cast< wxGrid * >(argp1);
18189 {
18190 arg2 = wxString_in_helper(obj1);
18191 if (arg2 == NULL) SWIG_fail;
18192 temp2 = true;
18193 }
18194 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18195 if (!SWIG_IsOK(res3)) {
18196 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18197 }
18198 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18199 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18200 if (!SWIG_IsOK(res4)) {
18201 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18202 }
18203 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 resultobj = SWIG_Py_Void();
18211 {
18212 if (temp2)
18213 delete arg2;
18214 }
18215 return resultobj;
18216 fail:
18217 {
18218 if (temp2)
18219 delete arg2;
18220 }
18221 return NULL;
18222 }
18223
18224
18225 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18226 PyObject *resultobj = 0;
18227 wxGrid *arg1 = (wxGrid *) 0 ;
18228 int arg2 ;
18229 int arg3 ;
18230 wxGridCellEditor *result = 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 int val2 ;
18234 int ecode2 = 0 ;
18235 int val3 ;
18236 int ecode3 = 0 ;
18237 PyObject * obj0 = 0 ;
18238 PyObject * obj1 = 0 ;
18239 PyObject * obj2 = 0 ;
18240 char * kwnames[] = {
18241 (char *) "self",(char *) "row",(char *) "col", NULL
18242 };
18243
18244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18246 if (!SWIG_IsOK(res1)) {
18247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18248 }
18249 arg1 = reinterpret_cast< wxGrid * >(argp1);
18250 ecode2 = SWIG_AsVal_int(obj1, &val2);
18251 if (!SWIG_IsOK(ecode2)) {
18252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18253 }
18254 arg2 = static_cast< int >(val2);
18255 ecode3 = SWIG_AsVal_int(obj2, &val3);
18256 if (!SWIG_IsOK(ecode3)) {
18257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18258 }
18259 arg3 = static_cast< int >(val3);
18260 {
18261 PyThreadState* __tstate = wxPyBeginAllowThreads();
18262 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18263 wxPyEndAllowThreads(__tstate);
18264 if (PyErr_Occurred()) SWIG_fail;
18265 }
18266 {
18267 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18268 }
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18276 PyObject *resultobj = 0;
18277 wxGrid *arg1 = (wxGrid *) 0 ;
18278 int arg2 ;
18279 int arg3 ;
18280 wxGridCellRenderer *result = 0 ;
18281 void *argp1 = 0 ;
18282 int res1 = 0 ;
18283 int val2 ;
18284 int ecode2 = 0 ;
18285 int val3 ;
18286 int ecode3 = 0 ;
18287 PyObject * obj0 = 0 ;
18288 PyObject * obj1 = 0 ;
18289 PyObject * obj2 = 0 ;
18290 char * kwnames[] = {
18291 (char *) "self",(char *) "row",(char *) "col", NULL
18292 };
18293
18294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18296 if (!SWIG_IsOK(res1)) {
18297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18298 }
18299 arg1 = reinterpret_cast< wxGrid * >(argp1);
18300 ecode2 = SWIG_AsVal_int(obj1, &val2);
18301 if (!SWIG_IsOK(ecode2)) {
18302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18303 }
18304 arg2 = static_cast< int >(val2);
18305 ecode3 = SWIG_AsVal_int(obj2, &val3);
18306 if (!SWIG_IsOK(ecode3)) {
18307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18308 }
18309 arg3 = static_cast< int >(val3);
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 {
18317 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18318 }
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18326 PyObject *resultobj = 0;
18327 wxGrid *arg1 = (wxGrid *) 0 ;
18328 wxString *arg2 = 0 ;
18329 wxGridCellEditor *result = 0 ;
18330 void *argp1 = 0 ;
18331 int res1 = 0 ;
18332 bool temp2 = false ;
18333 PyObject * obj0 = 0 ;
18334 PyObject * obj1 = 0 ;
18335 char * kwnames[] = {
18336 (char *) "self",(char *) "typeName", NULL
18337 };
18338
18339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18341 if (!SWIG_IsOK(res1)) {
18342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18343 }
18344 arg1 = reinterpret_cast< wxGrid * >(argp1);
18345 {
18346 arg2 = wxString_in_helper(obj1);
18347 if (arg2 == NULL) SWIG_fail;
18348 temp2 = true;
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 {
18357 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18358 }
18359 {
18360 if (temp2)
18361 delete arg2;
18362 }
18363 return resultobj;
18364 fail:
18365 {
18366 if (temp2)
18367 delete arg2;
18368 }
18369 return NULL;
18370 }
18371
18372
18373 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18374 PyObject *resultobj = 0;
18375 wxGrid *arg1 = (wxGrid *) 0 ;
18376 wxString *arg2 = 0 ;
18377 wxGridCellRenderer *result = 0 ;
18378 void *argp1 = 0 ;
18379 int res1 = 0 ;
18380 bool temp2 = false ;
18381 PyObject * obj0 = 0 ;
18382 PyObject * obj1 = 0 ;
18383 char * kwnames[] = {
18384 (char *) "self",(char *) "typeName", NULL
18385 };
18386
18387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18389 if (!SWIG_IsOK(res1)) {
18390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18391 }
18392 arg1 = reinterpret_cast< wxGrid * >(argp1);
18393 {
18394 arg2 = wxString_in_helper(obj1);
18395 if (arg2 == NULL) SWIG_fail;
18396 temp2 = true;
18397 }
18398 {
18399 PyThreadState* __tstate = wxPyBeginAllowThreads();
18400 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 {
18405 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18406 }
18407 {
18408 if (temp2)
18409 delete arg2;
18410 }
18411 return resultobj;
18412 fail:
18413 {
18414 if (temp2)
18415 delete arg2;
18416 }
18417 return NULL;
18418 }
18419
18420
18421 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18422 PyObject *resultobj = 0;
18423 wxGrid *arg1 = (wxGrid *) 0 ;
18424 int arg2 ;
18425 int arg3 ;
18426 void *argp1 = 0 ;
18427 int res1 = 0 ;
18428 int val2 ;
18429 int ecode2 = 0 ;
18430 int val3 ;
18431 int ecode3 = 0 ;
18432 PyObject * obj0 = 0 ;
18433 PyObject * obj1 = 0 ;
18434 PyObject * obj2 = 0 ;
18435 char * kwnames[] = {
18436 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18437 };
18438
18439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18441 if (!SWIG_IsOK(res1)) {
18442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18443 }
18444 arg1 = reinterpret_cast< wxGrid * >(argp1);
18445 ecode2 = SWIG_AsVal_int(obj1, &val2);
18446 if (!SWIG_IsOK(ecode2)) {
18447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18448 }
18449 arg2 = static_cast< int >(val2);
18450 ecode3 = SWIG_AsVal_int(obj2, &val3);
18451 if (!SWIG_IsOK(ecode3)) {
18452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18453 }
18454 arg3 = static_cast< int >(val3);
18455 {
18456 PyThreadState* __tstate = wxPyBeginAllowThreads();
18457 (arg1)->SetMargins(arg2,arg3);
18458 wxPyEndAllowThreads(__tstate);
18459 if (PyErr_Occurred()) SWIG_fail;
18460 }
18461 resultobj = SWIG_Py_Void();
18462 return resultobj;
18463 fail:
18464 return NULL;
18465 }
18466
18467
18468 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18469 PyObject *resultobj = 0;
18470 wxGrid *arg1 = (wxGrid *) 0 ;
18471 wxWindow *result = 0 ;
18472 void *argp1 = 0 ;
18473 int res1 = 0 ;
18474 PyObject *swig_obj[1] ;
18475
18476 if (!args) SWIG_fail;
18477 swig_obj[0] = args;
18478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18479 if (!SWIG_IsOK(res1)) {
18480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18481 }
18482 arg1 = reinterpret_cast< wxGrid * >(argp1);
18483 {
18484 PyThreadState* __tstate = wxPyBeginAllowThreads();
18485 result = (wxWindow *)(arg1)->GetGridWindow();
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 {
18490 resultobj = wxPyMake_wxObject(result, 0);
18491 }
18492 return resultobj;
18493 fail:
18494 return NULL;
18495 }
18496
18497
18498 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18499 PyObject *resultobj = 0;
18500 wxGrid *arg1 = (wxGrid *) 0 ;
18501 wxWindow *result = 0 ;
18502 void *argp1 = 0 ;
18503 int res1 = 0 ;
18504 PyObject *swig_obj[1] ;
18505
18506 if (!args) SWIG_fail;
18507 swig_obj[0] = args;
18508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18509 if (!SWIG_IsOK(res1)) {
18510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18511 }
18512 arg1 = reinterpret_cast< wxGrid * >(argp1);
18513 {
18514 PyThreadState* __tstate = wxPyBeginAllowThreads();
18515 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18516 wxPyEndAllowThreads(__tstate);
18517 if (PyErr_Occurred()) SWIG_fail;
18518 }
18519 {
18520 resultobj = wxPyMake_wxObject(result, 0);
18521 }
18522 return resultobj;
18523 fail:
18524 return NULL;
18525 }
18526
18527
18528 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18529 PyObject *resultobj = 0;
18530 wxGrid *arg1 = (wxGrid *) 0 ;
18531 wxWindow *result = 0 ;
18532 void *argp1 = 0 ;
18533 int res1 = 0 ;
18534 PyObject *swig_obj[1] ;
18535
18536 if (!args) SWIG_fail;
18537 swig_obj[0] = args;
18538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18539 if (!SWIG_IsOK(res1)) {
18540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18541 }
18542 arg1 = reinterpret_cast< wxGrid * >(argp1);
18543 {
18544 PyThreadState* __tstate = wxPyBeginAllowThreads();
18545 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 {
18550 resultobj = wxPyMake_wxObject(result, 0);
18551 }
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18559 PyObject *resultobj = 0;
18560 wxGrid *arg1 = (wxGrid *) 0 ;
18561 wxWindow *result = 0 ;
18562 void *argp1 = 0 ;
18563 int res1 = 0 ;
18564 PyObject *swig_obj[1] ;
18565
18566 if (!args) SWIG_fail;
18567 swig_obj[0] = args;
18568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18569 if (!SWIG_IsOK(res1)) {
18570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18571 }
18572 arg1 = reinterpret_cast< wxGrid * >(argp1);
18573 {
18574 PyThreadState* __tstate = wxPyBeginAllowThreads();
18575 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18576 wxPyEndAllowThreads(__tstate);
18577 if (PyErr_Occurred()) SWIG_fail;
18578 }
18579 {
18580 resultobj = wxPyMake_wxObject(result, 0);
18581 }
18582 return resultobj;
18583 fail:
18584 return NULL;
18585 }
18586
18587
18588 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj = 0;
18590 wxGrid *arg1 = (wxGrid *) 0 ;
18591 int arg2 ;
18592 void *argp1 = 0 ;
18593 int res1 = 0 ;
18594 int val2 ;
18595 int ecode2 = 0 ;
18596 PyObject * obj0 = 0 ;
18597 PyObject * obj1 = 0 ;
18598 char * kwnames[] = {
18599 (char *) "self",(char *) "x", NULL
18600 };
18601
18602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18604 if (!SWIG_IsOK(res1)) {
18605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18606 }
18607 arg1 = reinterpret_cast< wxGrid * >(argp1);
18608 ecode2 = SWIG_AsVal_int(obj1, &val2);
18609 if (!SWIG_IsOK(ecode2)) {
18610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18611 }
18612 arg2 = static_cast< int >(val2);
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 (arg1)->SetScrollLineX(arg2);
18616 wxPyEndAllowThreads(__tstate);
18617 if (PyErr_Occurred()) SWIG_fail;
18618 }
18619 resultobj = SWIG_Py_Void();
18620 return resultobj;
18621 fail:
18622 return NULL;
18623 }
18624
18625
18626 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18627 PyObject *resultobj = 0;
18628 wxGrid *arg1 = (wxGrid *) 0 ;
18629 int arg2 ;
18630 void *argp1 = 0 ;
18631 int res1 = 0 ;
18632 int val2 ;
18633 int ecode2 = 0 ;
18634 PyObject * obj0 = 0 ;
18635 PyObject * obj1 = 0 ;
18636 char * kwnames[] = {
18637 (char *) "self",(char *) "y", NULL
18638 };
18639
18640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18642 if (!SWIG_IsOK(res1)) {
18643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18644 }
18645 arg1 = reinterpret_cast< wxGrid * >(argp1);
18646 ecode2 = SWIG_AsVal_int(obj1, &val2);
18647 if (!SWIG_IsOK(ecode2)) {
18648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18649 }
18650 arg2 = static_cast< int >(val2);
18651 {
18652 PyThreadState* __tstate = wxPyBeginAllowThreads();
18653 (arg1)->SetScrollLineY(arg2);
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 resultobj = SWIG_Py_Void();
18658 return resultobj;
18659 fail:
18660 return NULL;
18661 }
18662
18663
18664 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18665 PyObject *resultobj = 0;
18666 wxGrid *arg1 = (wxGrid *) 0 ;
18667 int result;
18668 void *argp1 = 0 ;
18669 int res1 = 0 ;
18670 PyObject *swig_obj[1] ;
18671
18672 if (!args) SWIG_fail;
18673 swig_obj[0] = args;
18674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18675 if (!SWIG_IsOK(res1)) {
18676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18677 }
18678 arg1 = reinterpret_cast< wxGrid * >(argp1);
18679 {
18680 PyThreadState* __tstate = wxPyBeginAllowThreads();
18681 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 resultobj = SWIG_From_int(static_cast< int >(result));
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18693 PyObject *resultobj = 0;
18694 wxGrid *arg1 = (wxGrid *) 0 ;
18695 int result;
18696 void *argp1 = 0 ;
18697 int res1 = 0 ;
18698 PyObject *swig_obj[1] ;
18699
18700 if (!args) SWIG_fail;
18701 swig_obj[0] = args;
18702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18703 if (!SWIG_IsOK(res1)) {
18704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18705 }
18706 arg1 = reinterpret_cast< wxGrid * >(argp1);
18707 {
18708 PyThreadState* __tstate = wxPyBeginAllowThreads();
18709 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18710 wxPyEndAllowThreads(__tstate);
18711 if (PyErr_Occurred()) SWIG_fail;
18712 }
18713 resultobj = SWIG_From_int(static_cast< int >(result));
18714 return resultobj;
18715 fail:
18716 return NULL;
18717 }
18718
18719
18720 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18721 PyObject *resultobj = 0;
18722 wxGrid *arg1 = (wxGrid *) 0 ;
18723 int arg2 ;
18724 int result;
18725 void *argp1 = 0 ;
18726 int res1 = 0 ;
18727 int val2 ;
18728 int ecode2 = 0 ;
18729 PyObject * obj0 = 0 ;
18730 PyObject * obj1 = 0 ;
18731 char * kwnames[] = {
18732 (char *) "self",(char *) "x", NULL
18733 };
18734
18735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18737 if (!SWIG_IsOK(res1)) {
18738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18739 }
18740 arg1 = reinterpret_cast< wxGrid * >(argp1);
18741 ecode2 = SWIG_AsVal_int(obj1, &val2);
18742 if (!SWIG_IsOK(ecode2)) {
18743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18744 }
18745 arg2 = static_cast< int >(val2);
18746 {
18747 PyThreadState* __tstate = wxPyBeginAllowThreads();
18748 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18749 wxPyEndAllowThreads(__tstate);
18750 if (PyErr_Occurred()) SWIG_fail;
18751 }
18752 resultobj = SWIG_From_int(static_cast< int >(result));
18753 return resultobj;
18754 fail:
18755 return NULL;
18756 }
18757
18758
18759 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18760 PyObject *resultobj = 0;
18761 wxGrid *arg1 = (wxGrid *) 0 ;
18762 int arg2 ;
18763 int result;
18764 void *argp1 = 0 ;
18765 int res1 = 0 ;
18766 int val2 ;
18767 int ecode2 = 0 ;
18768 PyObject * obj0 = 0 ;
18769 PyObject * obj1 = 0 ;
18770 char * kwnames[] = {
18771 (char *) "self",(char *) "y", NULL
18772 };
18773
18774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18776 if (!SWIG_IsOK(res1)) {
18777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18778 }
18779 arg1 = reinterpret_cast< wxGrid * >(argp1);
18780 ecode2 = SWIG_AsVal_int(obj1, &val2);
18781 if (!SWIG_IsOK(ecode2)) {
18782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18783 }
18784 arg2 = static_cast< int >(val2);
18785 {
18786 PyThreadState* __tstate = wxPyBeginAllowThreads();
18787 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18788 wxPyEndAllowThreads(__tstate);
18789 if (PyErr_Occurred()) SWIG_fail;
18790 }
18791 resultobj = SWIG_From_int(static_cast< int >(result));
18792 return resultobj;
18793 fail:
18794 return NULL;
18795 }
18796
18797
18798 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj = 0;
18800 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18801 SwigValueWrapper<wxVisualAttributes > result;
18802 int val1 ;
18803 int ecode1 = 0 ;
18804 PyObject * obj0 = 0 ;
18805 char * kwnames[] = {
18806 (char *) "variant", NULL
18807 };
18808
18809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18810 if (obj0) {
18811 ecode1 = SWIG_AsVal_int(obj0, &val1);
18812 if (!SWIG_IsOK(ecode1)) {
18813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18814 }
18815 arg1 = static_cast< wxWindowVariant >(val1);
18816 }
18817 {
18818 if (!wxPyCheckForApp()) SWIG_fail;
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 result = wxGrid::GetClassDefaultAttributes(arg1);
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18825 return resultobj;
18826 fail:
18827 return NULL;
18828 }
18829
18830
18831 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18832 PyObject *obj;
18833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18834 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18835 return SWIG_Py_Void();
18836 }
18837
18838 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18839 return SWIG_Python_InitShadowInstance(args);
18840 }
18841
18842 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj = 0;
18844 int arg1 ;
18845 wxEventType arg2 ;
18846 wxGrid *arg3 = (wxGrid *) 0 ;
18847 int arg4 = (int) -1 ;
18848 int arg5 = (int) -1 ;
18849 int arg6 = (int) -1 ;
18850 int arg7 = (int) -1 ;
18851 bool arg8 = (bool) true ;
18852 bool arg9 = (bool) false ;
18853 bool arg10 = (bool) false ;
18854 bool arg11 = (bool) false ;
18855 bool arg12 = (bool) false ;
18856 wxGridEvent *result = 0 ;
18857 int val1 ;
18858 int ecode1 = 0 ;
18859 int val2 ;
18860 int ecode2 = 0 ;
18861 void *argp3 = 0 ;
18862 int res3 = 0 ;
18863 int val4 ;
18864 int ecode4 = 0 ;
18865 int val5 ;
18866 int ecode5 = 0 ;
18867 int val6 ;
18868 int ecode6 = 0 ;
18869 int val7 ;
18870 int ecode7 = 0 ;
18871 bool val8 ;
18872 int ecode8 = 0 ;
18873 bool val9 ;
18874 int ecode9 = 0 ;
18875 bool val10 ;
18876 int ecode10 = 0 ;
18877 bool val11 ;
18878 int ecode11 = 0 ;
18879 bool val12 ;
18880 int ecode12 = 0 ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 PyObject * obj2 = 0 ;
18884 PyObject * obj3 = 0 ;
18885 PyObject * obj4 = 0 ;
18886 PyObject * obj5 = 0 ;
18887 PyObject * obj6 = 0 ;
18888 PyObject * obj7 = 0 ;
18889 PyObject * obj8 = 0 ;
18890 PyObject * obj9 = 0 ;
18891 PyObject * obj10 = 0 ;
18892 PyObject * obj11 = 0 ;
18893 char * kwnames[] = {
18894 (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
18895 };
18896
18897 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;
18898 ecode1 = SWIG_AsVal_int(obj0, &val1);
18899 if (!SWIG_IsOK(ecode1)) {
18900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18901 }
18902 arg1 = static_cast< int >(val1);
18903 ecode2 = SWIG_AsVal_int(obj1, &val2);
18904 if (!SWIG_IsOK(ecode2)) {
18905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18906 }
18907 arg2 = static_cast< wxEventType >(val2);
18908 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18909 if (!SWIG_IsOK(res3)) {
18910 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18911 }
18912 arg3 = reinterpret_cast< wxGrid * >(argp3);
18913 if (obj3) {
18914 ecode4 = SWIG_AsVal_int(obj3, &val4);
18915 if (!SWIG_IsOK(ecode4)) {
18916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18917 }
18918 arg4 = static_cast< int >(val4);
18919 }
18920 if (obj4) {
18921 ecode5 = SWIG_AsVal_int(obj4, &val5);
18922 if (!SWIG_IsOK(ecode5)) {
18923 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18924 }
18925 arg5 = static_cast< int >(val5);
18926 }
18927 if (obj5) {
18928 ecode6 = SWIG_AsVal_int(obj5, &val6);
18929 if (!SWIG_IsOK(ecode6)) {
18930 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18931 }
18932 arg6 = static_cast< int >(val6);
18933 }
18934 if (obj6) {
18935 ecode7 = SWIG_AsVal_int(obj6, &val7);
18936 if (!SWIG_IsOK(ecode7)) {
18937 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18938 }
18939 arg7 = static_cast< int >(val7);
18940 }
18941 if (obj7) {
18942 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18943 if (!SWIG_IsOK(ecode8)) {
18944 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18945 }
18946 arg8 = static_cast< bool >(val8);
18947 }
18948 if (obj8) {
18949 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18950 if (!SWIG_IsOK(ecode9)) {
18951 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18952 }
18953 arg9 = static_cast< bool >(val9);
18954 }
18955 if (obj9) {
18956 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18957 if (!SWIG_IsOK(ecode10)) {
18958 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18959 }
18960 arg10 = static_cast< bool >(val10);
18961 }
18962 if (obj10) {
18963 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18964 if (!SWIG_IsOK(ecode11)) {
18965 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18966 }
18967 arg11 = static_cast< bool >(val11);
18968 }
18969 if (obj11) {
18970 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18971 if (!SWIG_IsOK(ecode12)) {
18972 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18973 }
18974 arg12 = static_cast< bool >(val12);
18975 }
18976 {
18977 PyThreadState* __tstate = wxPyBeginAllowThreads();
18978 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18979 wxPyEndAllowThreads(__tstate);
18980 if (PyErr_Occurred()) SWIG_fail;
18981 }
18982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18990 PyObject *resultobj = 0;
18991 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18992 int result;
18993 void *argp1 = 0 ;
18994 int res1 = 0 ;
18995 PyObject *swig_obj[1] ;
18996
18997 if (!args) SWIG_fail;
18998 swig_obj[0] = args;
18999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19000 if (!SWIG_IsOK(res1)) {
19001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19002 }
19003 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19004 {
19005 PyThreadState* __tstate = wxPyBeginAllowThreads();
19006 result = (int)(arg1)->GetRow();
19007 wxPyEndAllowThreads(__tstate);
19008 if (PyErr_Occurred()) SWIG_fail;
19009 }
19010 resultobj = SWIG_From_int(static_cast< int >(result));
19011 return resultobj;
19012 fail:
19013 return NULL;
19014 }
19015
19016
19017 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19018 PyObject *resultobj = 0;
19019 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19020 int result;
19021 void *argp1 = 0 ;
19022 int res1 = 0 ;
19023 PyObject *swig_obj[1] ;
19024
19025 if (!args) SWIG_fail;
19026 swig_obj[0] = args;
19027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19028 if (!SWIG_IsOK(res1)) {
19029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19030 }
19031 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = (int)(arg1)->GetCol();
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_From_int(static_cast< int >(result));
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19046 PyObject *resultobj = 0;
19047 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19048 wxPoint result;
19049 void *argp1 = 0 ;
19050 int res1 = 0 ;
19051 PyObject *swig_obj[1] ;
19052
19053 if (!args) SWIG_fail;
19054 swig_obj[0] = args;
19055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19056 if (!SWIG_IsOK(res1)) {
19057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19058 }
19059 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19060 {
19061 PyThreadState* __tstate = wxPyBeginAllowThreads();
19062 result = (arg1)->GetPosition();
19063 wxPyEndAllowThreads(__tstate);
19064 if (PyErr_Occurred()) SWIG_fail;
19065 }
19066 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19074 PyObject *resultobj = 0;
19075 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19076 bool result;
19077 void *argp1 = 0 ;
19078 int res1 = 0 ;
19079 PyObject *swig_obj[1] ;
19080
19081 if (!args) SWIG_fail;
19082 swig_obj[0] = args;
19083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19084 if (!SWIG_IsOK(res1)) {
19085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19086 }
19087 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19088 {
19089 PyThreadState* __tstate = wxPyBeginAllowThreads();
19090 result = (bool)(arg1)->Selecting();
19091 wxPyEndAllowThreads(__tstate);
19092 if (PyErr_Occurred()) SWIG_fail;
19093 }
19094 {
19095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19096 }
19097 return resultobj;
19098 fail:
19099 return NULL;
19100 }
19101
19102
19103 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19104 PyObject *resultobj = 0;
19105 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19106 bool result;
19107 void *argp1 = 0 ;
19108 int res1 = 0 ;
19109 PyObject *swig_obj[1] ;
19110
19111 if (!args) SWIG_fail;
19112 swig_obj[0] = args;
19113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19114 if (!SWIG_IsOK(res1)) {
19115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19116 }
19117 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19118 {
19119 PyThreadState* __tstate = wxPyBeginAllowThreads();
19120 result = (bool)(arg1)->ControlDown();
19121 wxPyEndAllowThreads(__tstate);
19122 if (PyErr_Occurred()) SWIG_fail;
19123 }
19124 {
19125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19126 }
19127 return resultobj;
19128 fail:
19129 return NULL;
19130 }
19131
19132
19133 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19134 PyObject *resultobj = 0;
19135 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19136 bool result;
19137 void *argp1 = 0 ;
19138 int res1 = 0 ;
19139 PyObject *swig_obj[1] ;
19140
19141 if (!args) SWIG_fail;
19142 swig_obj[0] = args;
19143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19144 if (!SWIG_IsOK(res1)) {
19145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19146 }
19147 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 result = (bool)(arg1)->MetaDown();
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 {
19155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19156 }
19157 return resultobj;
19158 fail:
19159 return NULL;
19160 }
19161
19162
19163 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19164 PyObject *resultobj = 0;
19165 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19166 bool result;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 PyObject *swig_obj[1] ;
19170
19171 if (!args) SWIG_fail;
19172 swig_obj[0] = args;
19173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19174 if (!SWIG_IsOK(res1)) {
19175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19176 }
19177 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19178 {
19179 PyThreadState* __tstate = wxPyBeginAllowThreads();
19180 result = (bool)(arg1)->ShiftDown();
19181 wxPyEndAllowThreads(__tstate);
19182 if (PyErr_Occurred()) SWIG_fail;
19183 }
19184 {
19185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19186 }
19187 return resultobj;
19188 fail:
19189 return NULL;
19190 }
19191
19192
19193 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19194 PyObject *resultobj = 0;
19195 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19196 bool result;
19197 void *argp1 = 0 ;
19198 int res1 = 0 ;
19199 PyObject *swig_obj[1] ;
19200
19201 if (!args) SWIG_fail;
19202 swig_obj[0] = args;
19203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19204 if (!SWIG_IsOK(res1)) {
19205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19206 }
19207 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19208 {
19209 PyThreadState* __tstate = wxPyBeginAllowThreads();
19210 result = (bool)(arg1)->AltDown();
19211 wxPyEndAllowThreads(__tstate);
19212 if (PyErr_Occurred()) SWIG_fail;
19213 }
19214 {
19215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19216 }
19217 return resultobj;
19218 fail:
19219 return NULL;
19220 }
19221
19222
19223 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19224 PyObject *resultobj = 0;
19225 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19226 bool result;
19227 void *argp1 = 0 ;
19228 int res1 = 0 ;
19229 PyObject *swig_obj[1] ;
19230
19231 if (!args) SWIG_fail;
19232 swig_obj[0] = args;
19233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19234 if (!SWIG_IsOK(res1)) {
19235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19236 }
19237 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19238 {
19239 PyThreadState* __tstate = wxPyBeginAllowThreads();
19240 result = (bool)(arg1)->CmdDown();
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 {
19245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19246 }
19247 return resultobj;
19248 fail:
19249 return NULL;
19250 }
19251
19252
19253 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19254 PyObject *obj;
19255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19256 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19257 return SWIG_Py_Void();
19258 }
19259
19260 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19261 return SWIG_Python_InitShadowInstance(args);
19262 }
19263
19264 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj = 0;
19266 int arg1 ;
19267 wxEventType arg2 ;
19268 wxGrid *arg3 = (wxGrid *) 0 ;
19269 int arg4 = (int) -1 ;
19270 int arg5 = (int) -1 ;
19271 int arg6 = (int) -1 ;
19272 bool arg7 = (bool) false ;
19273 bool arg8 = (bool) false ;
19274 bool arg9 = (bool) false ;
19275 bool arg10 = (bool) false ;
19276 wxGridSizeEvent *result = 0 ;
19277 int val1 ;
19278 int ecode1 = 0 ;
19279 int val2 ;
19280 int ecode2 = 0 ;
19281 void *argp3 = 0 ;
19282 int res3 = 0 ;
19283 int val4 ;
19284 int ecode4 = 0 ;
19285 int val5 ;
19286 int ecode5 = 0 ;
19287 int val6 ;
19288 int ecode6 = 0 ;
19289 bool val7 ;
19290 int ecode7 = 0 ;
19291 bool val8 ;
19292 int ecode8 = 0 ;
19293 bool val9 ;
19294 int ecode9 = 0 ;
19295 bool val10 ;
19296 int ecode10 = 0 ;
19297 PyObject * obj0 = 0 ;
19298 PyObject * obj1 = 0 ;
19299 PyObject * obj2 = 0 ;
19300 PyObject * obj3 = 0 ;
19301 PyObject * obj4 = 0 ;
19302 PyObject * obj5 = 0 ;
19303 PyObject * obj6 = 0 ;
19304 PyObject * obj7 = 0 ;
19305 PyObject * obj8 = 0 ;
19306 PyObject * obj9 = 0 ;
19307 char * kwnames[] = {
19308 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19309 };
19310
19311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19312 ecode1 = SWIG_AsVal_int(obj0, &val1);
19313 if (!SWIG_IsOK(ecode1)) {
19314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19315 }
19316 arg1 = static_cast< int >(val1);
19317 ecode2 = SWIG_AsVal_int(obj1, &val2);
19318 if (!SWIG_IsOK(ecode2)) {
19319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19320 }
19321 arg2 = static_cast< wxEventType >(val2);
19322 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19323 if (!SWIG_IsOK(res3)) {
19324 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19325 }
19326 arg3 = reinterpret_cast< wxGrid * >(argp3);
19327 if (obj3) {
19328 ecode4 = SWIG_AsVal_int(obj3, &val4);
19329 if (!SWIG_IsOK(ecode4)) {
19330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19331 }
19332 arg4 = static_cast< int >(val4);
19333 }
19334 if (obj4) {
19335 ecode5 = SWIG_AsVal_int(obj4, &val5);
19336 if (!SWIG_IsOK(ecode5)) {
19337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19338 }
19339 arg5 = static_cast< int >(val5);
19340 }
19341 if (obj5) {
19342 ecode6 = SWIG_AsVal_int(obj5, &val6);
19343 if (!SWIG_IsOK(ecode6)) {
19344 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19345 }
19346 arg6 = static_cast< int >(val6);
19347 }
19348 if (obj6) {
19349 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19350 if (!SWIG_IsOK(ecode7)) {
19351 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19352 }
19353 arg7 = static_cast< bool >(val7);
19354 }
19355 if (obj7) {
19356 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19357 if (!SWIG_IsOK(ecode8)) {
19358 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19359 }
19360 arg8 = static_cast< bool >(val8);
19361 }
19362 if (obj8) {
19363 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19364 if (!SWIG_IsOK(ecode9)) {
19365 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19366 }
19367 arg9 = static_cast< bool >(val9);
19368 }
19369 if (obj9) {
19370 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19371 if (!SWIG_IsOK(ecode10)) {
19372 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19373 }
19374 arg10 = static_cast< bool >(val10);
19375 }
19376 {
19377 PyThreadState* __tstate = wxPyBeginAllowThreads();
19378 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19390 PyObject *resultobj = 0;
19391 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19392 int result;
19393 void *argp1 = 0 ;
19394 int res1 = 0 ;
19395 PyObject *swig_obj[1] ;
19396
19397 if (!args) SWIG_fail;
19398 swig_obj[0] = args;
19399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19400 if (!SWIG_IsOK(res1)) {
19401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19402 }
19403 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19404 {
19405 PyThreadState* __tstate = wxPyBeginAllowThreads();
19406 result = (int)(arg1)->GetRowOrCol();
19407 wxPyEndAllowThreads(__tstate);
19408 if (PyErr_Occurred()) SWIG_fail;
19409 }
19410 resultobj = SWIG_From_int(static_cast< int >(result));
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19418 PyObject *resultobj = 0;
19419 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19420 wxPoint result;
19421 void *argp1 = 0 ;
19422 int res1 = 0 ;
19423 PyObject *swig_obj[1] ;
19424
19425 if (!args) SWIG_fail;
19426 swig_obj[0] = args;
19427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19428 if (!SWIG_IsOK(res1)) {
19429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19430 }
19431 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19432 {
19433 PyThreadState* __tstate = wxPyBeginAllowThreads();
19434 result = (arg1)->GetPosition();
19435 wxPyEndAllowThreads(__tstate);
19436 if (PyErr_Occurred()) SWIG_fail;
19437 }
19438 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19446 PyObject *resultobj = 0;
19447 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19448 bool result;
19449 void *argp1 = 0 ;
19450 int res1 = 0 ;
19451 PyObject *swig_obj[1] ;
19452
19453 if (!args) SWIG_fail;
19454 swig_obj[0] = args;
19455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19456 if (!SWIG_IsOK(res1)) {
19457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19458 }
19459 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19460 {
19461 PyThreadState* __tstate = wxPyBeginAllowThreads();
19462 result = (bool)(arg1)->ControlDown();
19463 wxPyEndAllowThreads(__tstate);
19464 if (PyErr_Occurred()) SWIG_fail;
19465 }
19466 {
19467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19468 }
19469 return resultobj;
19470 fail:
19471 return NULL;
19472 }
19473
19474
19475 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19476 PyObject *resultobj = 0;
19477 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19478 bool result;
19479 void *argp1 = 0 ;
19480 int res1 = 0 ;
19481 PyObject *swig_obj[1] ;
19482
19483 if (!args) SWIG_fail;
19484 swig_obj[0] = args;
19485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19486 if (!SWIG_IsOK(res1)) {
19487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19488 }
19489 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = (bool)(arg1)->MetaDown();
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 {
19497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19498 }
19499 return resultobj;
19500 fail:
19501 return NULL;
19502 }
19503
19504
19505 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19506 PyObject *resultobj = 0;
19507 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19508 bool result;
19509 void *argp1 = 0 ;
19510 int res1 = 0 ;
19511 PyObject *swig_obj[1] ;
19512
19513 if (!args) SWIG_fail;
19514 swig_obj[0] = args;
19515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19516 if (!SWIG_IsOK(res1)) {
19517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19518 }
19519 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19520 {
19521 PyThreadState* __tstate = wxPyBeginAllowThreads();
19522 result = (bool)(arg1)->ShiftDown();
19523 wxPyEndAllowThreads(__tstate);
19524 if (PyErr_Occurred()) SWIG_fail;
19525 }
19526 {
19527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19528 }
19529 return resultobj;
19530 fail:
19531 return NULL;
19532 }
19533
19534
19535 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19536 PyObject *resultobj = 0;
19537 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19538 bool result;
19539 void *argp1 = 0 ;
19540 int res1 = 0 ;
19541 PyObject *swig_obj[1] ;
19542
19543 if (!args) SWIG_fail;
19544 swig_obj[0] = args;
19545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19546 if (!SWIG_IsOK(res1)) {
19547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19548 }
19549 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19550 {
19551 PyThreadState* __tstate = wxPyBeginAllowThreads();
19552 result = (bool)(arg1)->AltDown();
19553 wxPyEndAllowThreads(__tstate);
19554 if (PyErr_Occurred()) SWIG_fail;
19555 }
19556 {
19557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19558 }
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19566 PyObject *resultobj = 0;
19567 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19568 bool result;
19569 void *argp1 = 0 ;
19570 int res1 = 0 ;
19571 PyObject *swig_obj[1] ;
19572
19573 if (!args) SWIG_fail;
19574 swig_obj[0] = args;
19575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19576 if (!SWIG_IsOK(res1)) {
19577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19578 }
19579 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19580 {
19581 PyThreadState* __tstate = wxPyBeginAllowThreads();
19582 result = (bool)(arg1)->CmdDown();
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 {
19587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19588 }
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19596 PyObject *obj;
19597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19598 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19599 return SWIG_Py_Void();
19600 }
19601
19602 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19603 return SWIG_Python_InitShadowInstance(args);
19604 }
19605
19606 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19607 PyObject *resultobj = 0;
19608 int arg1 ;
19609 wxEventType arg2 ;
19610 wxGrid *arg3 = (wxGrid *) 0 ;
19611 wxGridCellCoords *arg4 = 0 ;
19612 wxGridCellCoords *arg5 = 0 ;
19613 bool arg6 = (bool) true ;
19614 bool arg7 = (bool) false ;
19615 bool arg8 = (bool) false ;
19616 bool arg9 = (bool) false ;
19617 bool arg10 = (bool) false ;
19618 wxGridRangeSelectEvent *result = 0 ;
19619 int val1 ;
19620 int ecode1 = 0 ;
19621 int val2 ;
19622 int ecode2 = 0 ;
19623 void *argp3 = 0 ;
19624 int res3 = 0 ;
19625 wxGridCellCoords temp4 ;
19626 wxGridCellCoords temp5 ;
19627 bool val6 ;
19628 int ecode6 = 0 ;
19629 bool val7 ;
19630 int ecode7 = 0 ;
19631 bool val8 ;
19632 int ecode8 = 0 ;
19633 bool val9 ;
19634 int ecode9 = 0 ;
19635 bool val10 ;
19636 int ecode10 = 0 ;
19637 PyObject * obj0 = 0 ;
19638 PyObject * obj1 = 0 ;
19639 PyObject * obj2 = 0 ;
19640 PyObject * obj3 = 0 ;
19641 PyObject * obj4 = 0 ;
19642 PyObject * obj5 = 0 ;
19643 PyObject * obj6 = 0 ;
19644 PyObject * obj7 = 0 ;
19645 PyObject * obj8 = 0 ;
19646 PyObject * obj9 = 0 ;
19647 char * kwnames[] = {
19648 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19649 };
19650
19651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19652 ecode1 = SWIG_AsVal_int(obj0, &val1);
19653 if (!SWIG_IsOK(ecode1)) {
19654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19655 }
19656 arg1 = static_cast< int >(val1);
19657 ecode2 = SWIG_AsVal_int(obj1, &val2);
19658 if (!SWIG_IsOK(ecode2)) {
19659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19660 }
19661 arg2 = static_cast< wxEventType >(val2);
19662 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19663 if (!SWIG_IsOK(res3)) {
19664 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19665 }
19666 arg3 = reinterpret_cast< wxGrid * >(argp3);
19667 {
19668 arg4 = &temp4;
19669 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19670 }
19671 {
19672 arg5 = &temp5;
19673 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19674 }
19675 if (obj5) {
19676 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19677 if (!SWIG_IsOK(ecode6)) {
19678 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19679 }
19680 arg6 = static_cast< bool >(val6);
19681 }
19682 if (obj6) {
19683 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19684 if (!SWIG_IsOK(ecode7)) {
19685 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19686 }
19687 arg7 = static_cast< bool >(val7);
19688 }
19689 if (obj7) {
19690 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19691 if (!SWIG_IsOK(ecode8)) {
19692 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19693 }
19694 arg8 = static_cast< bool >(val8);
19695 }
19696 if (obj8) {
19697 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19698 if (!SWIG_IsOK(ecode9)) {
19699 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19700 }
19701 arg9 = static_cast< bool >(val9);
19702 }
19703 if (obj9) {
19704 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19705 if (!SWIG_IsOK(ecode10)) {
19706 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19707 }
19708 arg10 = static_cast< bool >(val10);
19709 }
19710 {
19711 PyThreadState* __tstate = wxPyBeginAllowThreads();
19712 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19713 wxPyEndAllowThreads(__tstate);
19714 if (PyErr_Occurred()) SWIG_fail;
19715 }
19716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19724 PyObject *resultobj = 0;
19725 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19726 wxGridCellCoords result;
19727 void *argp1 = 0 ;
19728 int res1 = 0 ;
19729 PyObject *swig_obj[1] ;
19730
19731 if (!args) SWIG_fail;
19732 swig_obj[0] = args;
19733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19734 if (!SWIG_IsOK(res1)) {
19735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19736 }
19737 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19738 {
19739 PyThreadState* __tstate = wxPyBeginAllowThreads();
19740 result = (arg1)->GetTopLeftCoords();
19741 wxPyEndAllowThreads(__tstate);
19742 if (PyErr_Occurred()) SWIG_fail;
19743 }
19744 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19752 PyObject *resultobj = 0;
19753 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19754 wxGridCellCoords result;
19755 void *argp1 = 0 ;
19756 int res1 = 0 ;
19757 PyObject *swig_obj[1] ;
19758
19759 if (!args) SWIG_fail;
19760 swig_obj[0] = args;
19761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19762 if (!SWIG_IsOK(res1)) {
19763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19764 }
19765 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19766 {
19767 PyThreadState* __tstate = wxPyBeginAllowThreads();
19768 result = (arg1)->GetBottomRightCoords();
19769 wxPyEndAllowThreads(__tstate);
19770 if (PyErr_Occurred()) SWIG_fail;
19771 }
19772 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19773 return resultobj;
19774 fail:
19775 return NULL;
19776 }
19777
19778
19779 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19780 PyObject *resultobj = 0;
19781 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19782 int result;
19783 void *argp1 = 0 ;
19784 int res1 = 0 ;
19785 PyObject *swig_obj[1] ;
19786
19787 if (!args) SWIG_fail;
19788 swig_obj[0] = args;
19789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19792 }
19793 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 result = (int)(arg1)->GetTopRow();
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 resultobj = SWIG_From_int(static_cast< int >(result));
19801 return resultobj;
19802 fail:
19803 return NULL;
19804 }
19805
19806
19807 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19808 PyObject *resultobj = 0;
19809 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19810 int result;
19811 void *argp1 = 0 ;
19812 int res1 = 0 ;
19813 PyObject *swig_obj[1] ;
19814
19815 if (!args) SWIG_fail;
19816 swig_obj[0] = args;
19817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19818 if (!SWIG_IsOK(res1)) {
19819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19820 }
19821 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19822 {
19823 PyThreadState* __tstate = wxPyBeginAllowThreads();
19824 result = (int)(arg1)->GetBottomRow();
19825 wxPyEndAllowThreads(__tstate);
19826 if (PyErr_Occurred()) SWIG_fail;
19827 }
19828 resultobj = SWIG_From_int(static_cast< int >(result));
19829 return resultobj;
19830 fail:
19831 return NULL;
19832 }
19833
19834
19835 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19836 PyObject *resultobj = 0;
19837 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19838 int result;
19839 void *argp1 = 0 ;
19840 int res1 = 0 ;
19841 PyObject *swig_obj[1] ;
19842
19843 if (!args) SWIG_fail;
19844 swig_obj[0] = args;
19845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19846 if (!SWIG_IsOK(res1)) {
19847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19848 }
19849 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19850 {
19851 PyThreadState* __tstate = wxPyBeginAllowThreads();
19852 result = (int)(arg1)->GetLeftCol();
19853 wxPyEndAllowThreads(__tstate);
19854 if (PyErr_Occurred()) SWIG_fail;
19855 }
19856 resultobj = SWIG_From_int(static_cast< int >(result));
19857 return resultobj;
19858 fail:
19859 return NULL;
19860 }
19861
19862
19863 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19864 PyObject *resultobj = 0;
19865 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19866 int result;
19867 void *argp1 = 0 ;
19868 int res1 = 0 ;
19869 PyObject *swig_obj[1] ;
19870
19871 if (!args) SWIG_fail;
19872 swig_obj[0] = args;
19873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19874 if (!SWIG_IsOK(res1)) {
19875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19876 }
19877 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19878 {
19879 PyThreadState* __tstate = wxPyBeginAllowThreads();
19880 result = (int)(arg1)->GetRightCol();
19881 wxPyEndAllowThreads(__tstate);
19882 if (PyErr_Occurred()) SWIG_fail;
19883 }
19884 resultobj = SWIG_From_int(static_cast< int >(result));
19885 return resultobj;
19886 fail:
19887 return NULL;
19888 }
19889
19890
19891 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19892 PyObject *resultobj = 0;
19893 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19894 bool result;
19895 void *argp1 = 0 ;
19896 int res1 = 0 ;
19897 PyObject *swig_obj[1] ;
19898
19899 if (!args) SWIG_fail;
19900 swig_obj[0] = args;
19901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19902 if (!SWIG_IsOK(res1)) {
19903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19904 }
19905 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19906 {
19907 PyThreadState* __tstate = wxPyBeginAllowThreads();
19908 result = (bool)(arg1)->Selecting();
19909 wxPyEndAllowThreads(__tstate);
19910 if (PyErr_Occurred()) SWIG_fail;
19911 }
19912 {
19913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19914 }
19915 return resultobj;
19916 fail:
19917 return NULL;
19918 }
19919
19920
19921 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19922 PyObject *resultobj = 0;
19923 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19924 bool result;
19925 void *argp1 = 0 ;
19926 int res1 = 0 ;
19927 PyObject *swig_obj[1] ;
19928
19929 if (!args) SWIG_fail;
19930 swig_obj[0] = args;
19931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19932 if (!SWIG_IsOK(res1)) {
19933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19934 }
19935 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 result = (bool)(arg1)->ControlDown();
19939 wxPyEndAllowThreads(__tstate);
19940 if (PyErr_Occurred()) SWIG_fail;
19941 }
19942 {
19943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19944 }
19945 return resultobj;
19946 fail:
19947 return NULL;
19948 }
19949
19950
19951 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19952 PyObject *resultobj = 0;
19953 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19954 bool result;
19955 void *argp1 = 0 ;
19956 int res1 = 0 ;
19957 PyObject *swig_obj[1] ;
19958
19959 if (!args) SWIG_fail;
19960 swig_obj[0] = args;
19961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19962 if (!SWIG_IsOK(res1)) {
19963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19964 }
19965 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19966 {
19967 PyThreadState* __tstate = wxPyBeginAllowThreads();
19968 result = (bool)(arg1)->MetaDown();
19969 wxPyEndAllowThreads(__tstate);
19970 if (PyErr_Occurred()) SWIG_fail;
19971 }
19972 {
19973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19974 }
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19982 PyObject *resultobj = 0;
19983 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19984 bool result;
19985 void *argp1 = 0 ;
19986 int res1 = 0 ;
19987 PyObject *swig_obj[1] ;
19988
19989 if (!args) SWIG_fail;
19990 swig_obj[0] = args;
19991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19992 if (!SWIG_IsOK(res1)) {
19993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19994 }
19995 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19996 {
19997 PyThreadState* __tstate = wxPyBeginAllowThreads();
19998 result = (bool)(arg1)->ShiftDown();
19999 wxPyEndAllowThreads(__tstate);
20000 if (PyErr_Occurred()) SWIG_fail;
20001 }
20002 {
20003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20004 }
20005 return resultobj;
20006 fail:
20007 return NULL;
20008 }
20009
20010
20011 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20012 PyObject *resultobj = 0;
20013 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20014 bool result;
20015 void *argp1 = 0 ;
20016 int res1 = 0 ;
20017 PyObject *swig_obj[1] ;
20018
20019 if (!args) SWIG_fail;
20020 swig_obj[0] = args;
20021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20022 if (!SWIG_IsOK(res1)) {
20023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20024 }
20025 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20026 {
20027 PyThreadState* __tstate = wxPyBeginAllowThreads();
20028 result = (bool)(arg1)->AltDown();
20029 wxPyEndAllowThreads(__tstate);
20030 if (PyErr_Occurred()) SWIG_fail;
20031 }
20032 {
20033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20034 }
20035 return resultobj;
20036 fail:
20037 return NULL;
20038 }
20039
20040
20041 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20042 PyObject *resultobj = 0;
20043 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20044 bool result;
20045 void *argp1 = 0 ;
20046 int res1 = 0 ;
20047 PyObject *swig_obj[1] ;
20048
20049 if (!args) SWIG_fail;
20050 swig_obj[0] = args;
20051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20052 if (!SWIG_IsOK(res1)) {
20053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20054 }
20055 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20056 {
20057 PyThreadState* __tstate = wxPyBeginAllowThreads();
20058 result = (bool)(arg1)->CmdDown();
20059 wxPyEndAllowThreads(__tstate);
20060 if (PyErr_Occurred()) SWIG_fail;
20061 }
20062 {
20063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20064 }
20065 return resultobj;
20066 fail:
20067 return NULL;
20068 }
20069
20070
20071 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20072 PyObject *obj;
20073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20074 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20075 return SWIG_Py_Void();
20076 }
20077
20078 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20079 return SWIG_Python_InitShadowInstance(args);
20080 }
20081
20082 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20083 PyObject *resultobj = 0;
20084 int arg1 ;
20085 wxEventType arg2 ;
20086 wxObject *arg3 = (wxObject *) 0 ;
20087 int arg4 ;
20088 int arg5 ;
20089 wxControl *arg6 = (wxControl *) 0 ;
20090 wxGridEditorCreatedEvent *result = 0 ;
20091 int val1 ;
20092 int ecode1 = 0 ;
20093 int val2 ;
20094 int ecode2 = 0 ;
20095 void *argp3 = 0 ;
20096 int res3 = 0 ;
20097 int val4 ;
20098 int ecode4 = 0 ;
20099 int val5 ;
20100 int ecode5 = 0 ;
20101 void *argp6 = 0 ;
20102 int res6 = 0 ;
20103 PyObject * obj0 = 0 ;
20104 PyObject * obj1 = 0 ;
20105 PyObject * obj2 = 0 ;
20106 PyObject * obj3 = 0 ;
20107 PyObject * obj4 = 0 ;
20108 PyObject * obj5 = 0 ;
20109 char * kwnames[] = {
20110 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20111 };
20112
20113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20114 ecode1 = SWIG_AsVal_int(obj0, &val1);
20115 if (!SWIG_IsOK(ecode1)) {
20116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20117 }
20118 arg1 = static_cast< int >(val1);
20119 ecode2 = SWIG_AsVal_int(obj1, &val2);
20120 if (!SWIG_IsOK(ecode2)) {
20121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20122 }
20123 arg2 = static_cast< wxEventType >(val2);
20124 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20125 if (!SWIG_IsOK(res3)) {
20126 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20127 }
20128 arg3 = reinterpret_cast< wxObject * >(argp3);
20129 ecode4 = SWIG_AsVal_int(obj3, &val4);
20130 if (!SWIG_IsOK(ecode4)) {
20131 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20132 }
20133 arg4 = static_cast< int >(val4);
20134 ecode5 = SWIG_AsVal_int(obj4, &val5);
20135 if (!SWIG_IsOK(ecode5)) {
20136 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20137 }
20138 arg5 = static_cast< int >(val5);
20139 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20140 if (!SWIG_IsOK(res6)) {
20141 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20142 }
20143 arg6 = reinterpret_cast< wxControl * >(argp6);
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20147 wxPyEndAllowThreads(__tstate);
20148 if (PyErr_Occurred()) SWIG_fail;
20149 }
20150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20151 return resultobj;
20152 fail:
20153 return NULL;
20154 }
20155
20156
20157 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20158 PyObject *resultobj = 0;
20159 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20160 int result;
20161 void *argp1 = 0 ;
20162 int res1 = 0 ;
20163 PyObject *swig_obj[1] ;
20164
20165 if (!args) SWIG_fail;
20166 swig_obj[0] = args;
20167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20168 if (!SWIG_IsOK(res1)) {
20169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20170 }
20171 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20172 {
20173 PyThreadState* __tstate = wxPyBeginAllowThreads();
20174 result = (int)(arg1)->GetRow();
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 resultobj = SWIG_From_int(static_cast< int >(result));
20179 return resultobj;
20180 fail:
20181 return NULL;
20182 }
20183
20184
20185 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20186 PyObject *resultobj = 0;
20187 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20188 int result;
20189 void *argp1 = 0 ;
20190 int res1 = 0 ;
20191 PyObject *swig_obj[1] ;
20192
20193 if (!args) SWIG_fail;
20194 swig_obj[0] = args;
20195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20196 if (!SWIG_IsOK(res1)) {
20197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20198 }
20199 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20200 {
20201 PyThreadState* __tstate = wxPyBeginAllowThreads();
20202 result = (int)(arg1)->GetCol();
20203 wxPyEndAllowThreads(__tstate);
20204 if (PyErr_Occurred()) SWIG_fail;
20205 }
20206 resultobj = SWIG_From_int(static_cast< int >(result));
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 PyObject *resultobj = 0;
20215 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20216 wxControl *result = 0 ;
20217 void *argp1 = 0 ;
20218 int res1 = 0 ;
20219 PyObject *swig_obj[1] ;
20220
20221 if (!args) SWIG_fail;
20222 swig_obj[0] = args;
20223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20224 if (!SWIG_IsOK(res1)) {
20225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20226 }
20227 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20228 {
20229 PyThreadState* __tstate = wxPyBeginAllowThreads();
20230 result = (wxControl *)(arg1)->GetControl();
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 {
20235 resultobj = wxPyMake_wxObject(result, 0);
20236 }
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20244 PyObject *resultobj = 0;
20245 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20246 int arg2 ;
20247 void *argp1 = 0 ;
20248 int res1 = 0 ;
20249 int val2 ;
20250 int ecode2 = 0 ;
20251 PyObject * obj0 = 0 ;
20252 PyObject * obj1 = 0 ;
20253 char * kwnames[] = {
20254 (char *) "self",(char *) "row", NULL
20255 };
20256
20257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20259 if (!SWIG_IsOK(res1)) {
20260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20261 }
20262 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20263 ecode2 = SWIG_AsVal_int(obj1, &val2);
20264 if (!SWIG_IsOK(ecode2)) {
20265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20266 }
20267 arg2 = static_cast< int >(val2);
20268 {
20269 PyThreadState* __tstate = wxPyBeginAllowThreads();
20270 (arg1)->SetRow(arg2);
20271 wxPyEndAllowThreads(__tstate);
20272 if (PyErr_Occurred()) SWIG_fail;
20273 }
20274 resultobj = SWIG_Py_Void();
20275 return resultobj;
20276 fail:
20277 return NULL;
20278 }
20279
20280
20281 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20282 PyObject *resultobj = 0;
20283 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20284 int arg2 ;
20285 void *argp1 = 0 ;
20286 int res1 = 0 ;
20287 int val2 ;
20288 int ecode2 = 0 ;
20289 PyObject * obj0 = 0 ;
20290 PyObject * obj1 = 0 ;
20291 char * kwnames[] = {
20292 (char *) "self",(char *) "col", NULL
20293 };
20294
20295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20297 if (!SWIG_IsOK(res1)) {
20298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20299 }
20300 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20301 ecode2 = SWIG_AsVal_int(obj1, &val2);
20302 if (!SWIG_IsOK(ecode2)) {
20303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20304 }
20305 arg2 = static_cast< int >(val2);
20306 {
20307 PyThreadState* __tstate = wxPyBeginAllowThreads();
20308 (arg1)->SetCol(arg2);
20309 wxPyEndAllowThreads(__tstate);
20310 if (PyErr_Occurred()) SWIG_fail;
20311 }
20312 resultobj = SWIG_Py_Void();
20313 return resultobj;
20314 fail:
20315 return NULL;
20316 }
20317
20318
20319 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20320 PyObject *resultobj = 0;
20321 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20322 wxControl *arg2 = (wxControl *) 0 ;
20323 void *argp1 = 0 ;
20324 int res1 = 0 ;
20325 void *argp2 = 0 ;
20326 int res2 = 0 ;
20327 PyObject * obj0 = 0 ;
20328 PyObject * obj1 = 0 ;
20329 char * kwnames[] = {
20330 (char *) "self",(char *) "ctrl", NULL
20331 };
20332
20333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20335 if (!SWIG_IsOK(res1)) {
20336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20337 }
20338 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20340 if (!SWIG_IsOK(res2)) {
20341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20342 }
20343 arg2 = reinterpret_cast< wxControl * >(argp2);
20344 {
20345 PyThreadState* __tstate = wxPyBeginAllowThreads();
20346 (arg1)->SetControl(arg2);
20347 wxPyEndAllowThreads(__tstate);
20348 if (PyErr_Occurred()) SWIG_fail;
20349 }
20350 resultobj = SWIG_Py_Void();
20351 return resultobj;
20352 fail:
20353 return NULL;
20354 }
20355
20356
20357 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 PyObject *obj;
20359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20360 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20361 return SWIG_Py_Void();
20362 }
20363
20364 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20365 return SWIG_Python_InitShadowInstance(args);
20366 }
20367
20368 static PyMethodDef SwigMethods[] = {
20369 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20370 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20371 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20372 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20373 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20374 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20375 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20376 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20377 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20378 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20379 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20380 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20381 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20382 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20383 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20384 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20385 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20386 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20387 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20388 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20389 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20391 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20392 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20393 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20394 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20395 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20396 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20397 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20399 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20400 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20401 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20402 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20403 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20404 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20405 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20406 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20407 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20408 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20409 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20410 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20411 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20415 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20416 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20419 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20422 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20423 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20424 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20425 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20426 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20427 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20429 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20430 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20431 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20432 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20433 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20434 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20435 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20436 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20437 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20438 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20439 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20440 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20441 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
20442 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20443 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20444 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20445 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
20446 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20447 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20448 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20449 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20450 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20451 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20452 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20453 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20454 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20455 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20456 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20457 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20458 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20459 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20460 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20461 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20462 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20465 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20466 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20467 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20468 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20469 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20470 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20471 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20472 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20473 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20474 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20475 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20476 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20477 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20478 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20479 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20480 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20481 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20482 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20483 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20484 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20485 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20486 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20488 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20489 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20490 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20491 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20492 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20493 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20494 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20496 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20497 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20500 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20501 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20502 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20503 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20504 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20509 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20510 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20511 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20514 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20516 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20517 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20518 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20531 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20532 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20533 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20535 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20542 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20543 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20547 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20548 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20550 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20551 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20552 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20554 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20555 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20557 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20559 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20561 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20563 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20564 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20565 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20566 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20567 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20568 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20569 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20570 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20571 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20572 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20577 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20578 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20579 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20581 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20585 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20586 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20587 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20589 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20591 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20601 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20602 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20603 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20604 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20605 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20608 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20609 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20610 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20611 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20612 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20613 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20614 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20615 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20622 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20623 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20631 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20632 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20637 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20638 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20639 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20640 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20641 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20642 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20643 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20644 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20645 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20646 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20649 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20650 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20653 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20654 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20655 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20671 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20672 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20674 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20675 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20677 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20678 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20680 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20681 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20683 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20684 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20694 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20695 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20697 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20699 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20701 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20703 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20705 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20707 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20721 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20728 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20729 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20743 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20747 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20756 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20757 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20758 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20760 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20761 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20762 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20763 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20764 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20769 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20770 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20779 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20780 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20781 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20782 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20785 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20786 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20790 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20791 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20793 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20794 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20795 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20796 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20797 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20798 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20799 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20800 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20801 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20802 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20803 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20805 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20806 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20807 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20808 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20809 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20810 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20811 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20812 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20813 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20815 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20816 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20817 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20818 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20819 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20820 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20821 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20822 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20823 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20824 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20825 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20826 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20827 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20828 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20830 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20831 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20832 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20836 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20837 { NULL, NULL, 0, NULL }
20838 };
20839
20840
20841 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20842
20843 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20844 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20845 }
20846 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20847 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20848 }
20849 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20850 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20851 }
20852 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20853 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20854 }
20855 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20856 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20857 }
20858 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20859 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20860 }
20861 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20862 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20863 }
20864 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20865 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20866 }
20867 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20868 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20869 }
20870 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20871 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20872 }
20873 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20874 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20875 }
20876 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20877 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20878 }
20879 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20880 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20881 }
20882 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20883 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20884 }
20885 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20886 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20887 }
20888 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20889 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20890 }
20891 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20892 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20893 }
20894 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20895 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20896 }
20897 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20898 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20899 }
20900 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20901 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20902 }
20903 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20904 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20905 }
20906 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20907 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20908 }
20909 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20910 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20911 }
20912 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20913 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20914 }
20915 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20916 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20917 }
20918 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20919 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20920 }
20921 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20922 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20923 }
20924 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20925 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20926 }
20927 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20928 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20929 }
20930 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20931 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20932 }
20933 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20934 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20935 }
20936 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20937 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20938 }
20939 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20940 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20941 }
20942 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20943 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20944 }
20945 static void *_p_wxGridTo_p_wxPanel(void *x) {
20946 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20947 }
20948 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20949 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20950 }
20951 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20952 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20953 }
20954 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20955 return (void *)((wxPanel *) ((wxPyPanel *) x));
20956 }
20957 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20958 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20959 }
20960 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20961 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20962 }
20963 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20964 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20965 }
20966 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20967 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20968 }
20969 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20970 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20971 }
20972 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20973 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20974 }
20975 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20976 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20977 }
20978 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20979 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20980 }
20981 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20982 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20983 }
20984 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20985 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20986 }
20987 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20988 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20989 }
20990 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20991 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20992 }
20993 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20994 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20995 }
20996 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20997 return (void *)((wxWindow *) ((wxMenuBar *) x));
20998 }
20999 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21000 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21001 }
21002 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21003 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21004 }
21005 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21006 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21007 }
21008 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21009 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21010 }
21011 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21012 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21013 }
21014 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21015 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21016 }
21017 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21018 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21019 }
21020 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21021 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21022 }
21023 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21024 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21025 }
21026 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21027 return (void *)((wxWindow *) ((wxPanel *) x));
21028 }
21029 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21030 return (void *)((wxWindow *) ((wxStatusBar *) x));
21031 }
21032 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21033 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21034 }
21035 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21036 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21037 }
21038 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21039 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21040 }
21041 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21042 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21043 }
21044 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21045 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21046 }
21047 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21048 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21049 }
21050 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21051 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21052 }
21053 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21054 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21055 }
21056 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21057 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21058 }
21059 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21060 return (void *)((wxWindow *) ((wxSashWindow *) x));
21061 }
21062 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21063 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21064 }
21065 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21066 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21067 }
21068 static void *_p_wxControlTo_p_wxWindow(void *x) {
21069 return (void *)((wxWindow *) ((wxControl *) x));
21070 }
21071 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21072 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21073 }
21074 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21075 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21076 }
21077 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21078 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21079 }
21080 static void *_p_wxGridTo_p_wxWindow(void *x) {
21081 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21082 }
21083 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21084 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21085 }
21086 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21087 return (void *)((wxWindow *) ((wxPyWindow *) x));
21088 }
21089 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21090 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21091 }
21092 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21093 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21094 }
21095 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21096 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21097 }
21098 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21099 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21100 }
21101 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21102 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21103 }
21104 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21105 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21106 }
21107 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21108 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21109 }
21110 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21111 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21112 }
21113 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21114 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21115 }
21116 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21117 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21118 }
21119 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21120 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21121 }
21122 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21123 return (void *)((wxControl *) ((wxControlWithItems *) x));
21124 }
21125 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21126 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21127 }
21128 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21129 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21130 }
21131 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21132 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21133 }
21134 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21135 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21136 }
21137 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21138 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21139 }
21140 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21141 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21142 }
21143 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21144 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21145 }
21146 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21147 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21148 }
21149 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21150 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21151 }
21152 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21153 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21154 }
21155 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21156 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21157 }
21158 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21159 return (void *)((wxEvent *) ((wxPyEvent *) x));
21160 }
21161 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21162 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21163 }
21164 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21165 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21166 }
21167 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21168 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21169 }
21170 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21171 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21172 }
21173 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21174 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21175 }
21176 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21177 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21178 }
21179 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21180 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21181 }
21182 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21183 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21184 }
21185 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21186 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21187 }
21188 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21189 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21190 }
21191 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21192 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21193 }
21194 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21195 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21196 }
21197 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21198 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21199 }
21200 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21201 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21202 }
21203 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21204 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21205 }
21206 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21207 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21208 }
21209 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21210 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21211 }
21212 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21213 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21214 }
21215 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21216 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21217 }
21218 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21219 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21220 }
21221 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21222 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21223 }
21224 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21225 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21226 }
21227 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21228 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21229 }
21230 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21231 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21232 }
21233 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21234 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21235 }
21236 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21237 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21238 }
21239 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21240 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21241 }
21242 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21243 return (void *)((wxEvent *) ((wxShowEvent *) x));
21244 }
21245 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21246 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21247 }
21248 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21249 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21250 }
21251 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21253 }
21254 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21255 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21256 }
21257 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21258 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21259 }
21260 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21261 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21262 }
21263 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21264 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21265 }
21266 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21267 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21268 }
21269 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21270 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21271 }
21272 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21273 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21274 }
21275 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21276 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21277 }
21278 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21279 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21280 }
21281 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21282 return (void *)((wxObject *) ((wxSizerItem *) x));
21283 }
21284 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21285 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21286 }
21287 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21288 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21289 }
21290 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21291 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21292 }
21293 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21294 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21295 }
21296 static void *_p_wxSizerTo_p_wxObject(void *x) {
21297 return (void *)((wxObject *) ((wxSizer *) x));
21298 }
21299 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21300 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21301 }
21302 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21303 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21304 }
21305 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21306 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21307 }
21308 static void *_p_wxEventTo_p_wxObject(void *x) {
21309 return (void *)((wxObject *) ((wxEvent *) x));
21310 }
21311 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21312 return (void *)((wxObject *) ((wxFontData *) x));
21313 }
21314 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21315 return (void *)((wxObject *) ((wxPrintData *) x));
21316 }
21317 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21318 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21319 }
21320 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21321 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21322 }
21323 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21324 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21325 }
21326 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21327 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21328 }
21329 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21330 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21331 }
21332 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21333 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21334 }
21335 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21336 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21337 }
21338 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21339 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21340 }
21341 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21342 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21343 }
21344 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21345 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21346 }
21347 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21348 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21349 }
21350 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21351 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21352 }
21353 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21354 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21355 }
21356 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21357 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21358 }
21359 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21360 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21361 }
21362 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21363 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21364 }
21365 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21366 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21367 }
21368 static void *_p_wxControlTo_p_wxObject(void *x) {
21369 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21370 }
21371 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21372 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21373 }
21374 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21375 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21376 }
21377 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21378 return (void *)((wxObject *) ((wxFSFile *) x));
21379 }
21380 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21381 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21382 }
21383 static void *_p_wxGridTo_p_wxObject(void *x) {
21384 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21385 }
21386 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21387 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21388 }
21389 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21390 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21391 }
21392 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21393 return (void *)((wxObject *) ((wxColourData *) x));
21394 }
21395 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21396 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21397 }
21398 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21399 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21400 }
21401 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21402 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21403 }
21404 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21405 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21406 }
21407 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21408 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21409 }
21410 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21411 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21412 }
21413 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21414 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21415 }
21416 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21417 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21418 }
21419 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21420 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21421 }
21422 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21423 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21424 }
21425 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21426 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21427 }
21428 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21429 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21430 }
21431 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21432 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21433 }
21434 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21435 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21436 }
21437 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21438 return (void *)((wxObject *) ((wxPrinter *) x));
21439 }
21440 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21441 return (void *)((wxObject *) ((wxMenuItem *) x));
21442 }
21443 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21445 }
21446 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21447 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21448 }
21449 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21450 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21451 }
21452 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21453 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21454 }
21455 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21456 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21457 }
21458 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21459 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21460 }
21461 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21462 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21463 }
21464 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21465 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21466 }
21467 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21468 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21469 }
21470 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21471 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21472 }
21473 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21474 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21475 }
21476 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21477 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21478 }
21479 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21480 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21481 }
21482 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21483 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21484 }
21485 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21486 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21487 }
21488 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21489 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21490 }
21491 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21492 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21493 }
21494 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21495 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21496 }
21497 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21498 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21499 }
21500 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21501 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21502 }
21503 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21504 return (void *)((wxObject *) ((wxImageHandler *) x));
21505 }
21506 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21507 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21508 }
21509 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21510 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21511 }
21512 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21513 return (void *)((wxObject *) ((wxEvtHandler *) x));
21514 }
21515 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21516 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21517 }
21518 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21519 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21520 }
21521 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21522 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21523 }
21524 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21525 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21526 }
21527 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21528 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21529 }
21530 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21531 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21532 }
21533 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21534 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21535 }
21536 static void *_p_wxImageTo_p_wxObject(void *x) {
21537 return (void *)((wxObject *) ((wxImage *) x));
21538 }
21539 static void *_p_wxFrameTo_p_wxObject(void *x) {
21540 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21541 }
21542 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21543 return (void *)((wxObject *) ((wxPyPrintout *) x));
21544 }
21545 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21546 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21547 }
21548 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21549 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21550 }
21551 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21552 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21553 }
21554 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21555 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21556 }
21557 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21558 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21559 }
21560 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21561 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21562 }
21563 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21564 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21565 }
21566 static void *_p_wxWindowTo_p_wxObject(void *x) {
21567 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21568 }
21569 static void *_p_wxMenuTo_p_wxObject(void *x) {
21570 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21571 }
21572 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21573 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21574 }
21575 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21576 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21577 }
21578 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21579 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21580 }
21581 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21582 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21583 }
21584 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21585 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21586 }
21587 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21588 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21589 }
21590 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21591 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21592 }
21593 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21594 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21595 }
21596 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21597 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21598 }
21599 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21600 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21601 }
21602 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21603 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21604 }
21605 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21606 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21607 }
21608 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21609 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21610 }
21611 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21612 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21613 }
21614 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21615 return (void *)((wxObject *) ((wxPrintPreview *) x));
21616 }
21617 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21618 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21619 }
21620 static void *_p_wxPanelTo_p_wxObject(void *x) {
21621 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21622 }
21623 static void *_p_wxDialogTo_p_wxObject(void *x) {
21624 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21625 }
21626 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21627 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21628 }
21629 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21630 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21631 }
21632 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21633 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21634 }
21635 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21636 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21637 }
21638 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21639 return (void *)((wxObject *) ((wxPrintDialog *) x));
21640 }
21641 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21642 return (void *)((wxObject *) ((wxFileSystem *) x));
21643 }
21644 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21645 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21646 }
21647 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21648 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21649 }
21650 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21651 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21652 }
21653 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21654 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21655 }
21656 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21657 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21658 }
21659 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21660 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21661 }
21662 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21663 return (void *)((wxObject *) ((wxGridTableBase *) x));
21664 }
21665 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21666 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21667 }
21668 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21669 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21670 }
21671 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21672 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21673 }
21674 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21675 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21676 }
21677 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21678 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21679 }
21680 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21681 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21682 }
21683 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21684 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21685 }
21686 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21687 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21688 }
21689 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21690 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21691 }
21692 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21693 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21694 }
21695 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21696 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21697 }
21698 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21699 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21700 }
21701 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21702 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21703 }
21704 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21705 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21706 }
21707 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21708 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21709 }
21710 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21711 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21712 }
21713 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21714 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21715 }
21716 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21717 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21718 }
21719 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21720 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21721 }
21722 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21723 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21724 }
21725 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21726 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21727 }
21728 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21729 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21730 }
21731 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21732 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21733 }
21734 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21735 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21736 }
21737 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21738 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21739 }
21740 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
21741 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21742 }
21743 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21744 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21745 }
21746 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21747 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21748 }
21749 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21750 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21751 }
21752 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21753 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21754 }
21755 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21756 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21757 }
21758 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21759 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21760 }
21761 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21762 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21763 }
21764 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21765 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21766 }
21767 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21768 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21769 }
21770 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21771 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21772 }
21773 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21774 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21775 }
21776 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21777 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21778 }
21779 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21780 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21781 }
21782 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21783 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21784 }
21785 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21786 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21787 }
21788 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21789 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21790 }
21791 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21792 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21793 }
21794 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21795 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21796 }
21797 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21798 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21799 }
21800 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21801 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21802 }
21803 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21804 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21805 }
21806 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21807 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21808 }
21809 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21810 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21811 }
21812 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21813 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21814 }
21815 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21816 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21817 }
21818 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21819 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21820 }
21821 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21822 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21823 }
21824 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21825 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21826 }
21827 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21828 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21829 }
21830 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21831 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21832 }
21833 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21834 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21835 }
21836 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21837 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21838 }
21839 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21840 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21841 }
21842 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21843 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21844 }
21845 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21846 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21847 }
21848 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21849 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21850 }
21851 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21852 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21853 }
21854 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21855 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21856 }
21857 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21858 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21859 }
21860 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21861 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21862 }
21863 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21864 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21865 }
21866 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21867 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21868 }
21869 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21870 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21871 }
21872 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21873 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21874 }
21875 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21876 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21877 }
21878 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21879 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21880 }
21881 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21882 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21883 }
21884 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21885 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21886 }
21887 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21888 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21889 }
21890 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21891 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21892 }
21893 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21894 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21895 }
21896 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21897 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21898 }
21899 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21900 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21901 }
21902 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21903 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21904 }
21905 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
21906 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
21907 }
21908 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21909 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21910 }
21911 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21912 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21913 }
21914 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21915 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21916 }
21917 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21918 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21919 }
21920 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21921 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21922 }
21923 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21924 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21925 }
21926 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21927 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21928 }
21929 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21930 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21931 }
21932 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21933 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21934 }
21935 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21936 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21937 }
21938 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21939 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21940 }
21941 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21942 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21943 }
21944 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21945 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21946 }
21947 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21948 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21949 }
21950 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21951 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21952 }
21953 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21954 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};
21955 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21956 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21957 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21958 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21959 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21960 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21961 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21962 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21963 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21964 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21965 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21966 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
21967 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21968 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21969 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21970 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21971 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21972 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21973 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21974 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21975 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21976 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21977 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21978 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21979 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21980 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21981 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21982 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21983 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21984 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21985 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21986 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21987 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21988 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21989 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21990 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21991 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21992 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21993 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21994 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21995 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21996 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21997 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21998 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21999 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22000 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22001 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22002 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22003 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22004 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22005 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22006 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22007 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22008 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22009 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22010 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22011 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22012 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22013 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22014 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22015 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22016 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22017 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22018 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22019 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22020 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22021 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22022 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22023 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22024 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22025 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22026 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22027 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22028 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22029 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22030 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22031 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22032 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22033 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22034 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22035 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22036 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22037 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22038 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22039 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22040 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22041 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22042 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22043 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22044 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22045 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22046 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22047 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22048 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22049 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22050 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22051 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22052 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22053 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22054 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22055 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22056 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22057 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22058 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22059 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22060 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22061 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22062 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22063 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22064 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22065 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22066 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22067 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22068 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22069 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22070 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22071 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22072 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22073 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22074 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22075 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22076 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22077 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22078 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22079 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22080 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22081 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22082 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22083 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22084 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22085 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22086 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22087 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22088 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22089 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22090 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22091 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22092 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22093 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22094 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22095 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22096 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22097 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22098 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22099 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22100 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22101 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22102 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22103 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22104 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22105 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22106 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22107 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22108 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22109 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22110 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22111 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22112 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22113 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22114 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22115 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22116 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22117 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22118 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22119 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22120 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22121 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22122 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22123 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22124 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22125 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22126 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22127 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22128 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22129 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22130 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22131 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22132 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22133 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22134 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22135 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22136 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22137 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22138 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22139 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22140 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22141 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22142
22143 static swig_type_info *swig_type_initial[] = {
22144 &_swigt__p_char,
22145 &_swigt__p_form_ops_t,
22146 &_swigt__p_int,
22147 &_swigt__p_long,
22148 &_swigt__p_unsigned_char,
22149 &_swigt__p_unsigned_int,
22150 &_swigt__p_unsigned_long,
22151 &_swigt__p_wxANIHandler,
22152 &_swigt__p_wxAcceleratorTable,
22153 &_swigt__p_wxActivateEvent,
22154 &_swigt__p_wxArrayString,
22155 &_swigt__p_wxBMPHandler,
22156 &_swigt__p_wxBoxSizer,
22157 &_swigt__p_wxCURHandler,
22158 &_swigt__p_wxCalculateLayoutEvent,
22159 &_swigt__p_wxChildFocusEvent,
22160 &_swigt__p_wxClipboardTextEvent,
22161 &_swigt__p_wxCloseEvent,
22162 &_swigt__p_wxColour,
22163 &_swigt__p_wxColourData,
22164 &_swigt__p_wxColourDialog,
22165 &_swigt__p_wxCommandEvent,
22166 &_swigt__p_wxContextMenuEvent,
22167 &_swigt__p_wxControl,
22168 &_swigt__p_wxControlWithItems,
22169 &_swigt__p_wxDC,
22170 &_swigt__p_wxDateEvent,
22171 &_swigt__p_wxDialog,
22172 &_swigt__p_wxDirDialog,
22173 &_swigt__p_wxDisplayChangedEvent,
22174 &_swigt__p_wxDropFilesEvent,
22175 &_swigt__p_wxDuplexMode,
22176 &_swigt__p_wxEraseEvent,
22177 &_swigt__p_wxEvent,
22178 &_swigt__p_wxEvtHandler,
22179 &_swigt__p_wxFSFile,
22180 &_swigt__p_wxFileDialog,
22181 &_swigt__p_wxFileSystem,
22182 &_swigt__p_wxFindDialogEvent,
22183 &_swigt__p_wxFindReplaceData,
22184 &_swigt__p_wxFindReplaceDialog,
22185 &_swigt__p_wxFlexGridSizer,
22186 &_swigt__p_wxFocusEvent,
22187 &_swigt__p_wxFont,
22188 &_swigt__p_wxFontData,
22189 &_swigt__p_wxFontDialog,
22190 &_swigt__p_wxFrame,
22191 &_swigt__p_wxGBSizerItem,
22192 &_swigt__p_wxGIFHandler,
22193 &_swigt__p_wxGrid,
22194 &_swigt__p_wxGridBagSizer,
22195 &_swigt__p_wxGridCellAttr,
22196 &_swigt__p_wxGridCellAttrProvider,
22197 &_swigt__p_wxGridCellAutoWrapStringEditor,
22198 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22199 &_swigt__p_wxGridCellBoolEditor,
22200 &_swigt__p_wxGridCellBoolRenderer,
22201 &_swigt__p_wxGridCellChoiceEditor,
22202 &_swigt__p_wxGridCellCoords,
22203 &_swigt__p_wxGridCellDateTimeRenderer,
22204 &_swigt__p_wxGridCellEditor,
22205 &_swigt__p_wxGridCellEnumEditor,
22206 &_swigt__p_wxGridCellEnumRenderer,
22207 &_swigt__p_wxGridCellFloatEditor,
22208 &_swigt__p_wxGridCellFloatRenderer,
22209 &_swigt__p_wxGridCellNumberEditor,
22210 &_swigt__p_wxGridCellNumberRenderer,
22211 &_swigt__p_wxGridCellRenderer,
22212 &_swigt__p_wxGridCellStringRenderer,
22213 &_swigt__p_wxGridCellTextEditor,
22214 &_swigt__p_wxGridCellWorker,
22215 &_swigt__p_wxGridEditorCreatedEvent,
22216 &_swigt__p_wxGridEvent,
22217 &_swigt__p_wxGridRangeSelectEvent,
22218 &_swigt__p_wxGridSizeEvent,
22219 &_swigt__p_wxGridSizer,
22220 &_swigt__p_wxGridStringTable,
22221 &_swigt__p_wxGridTableBase,
22222 &_swigt__p_wxGridTableMessage,
22223 &_swigt__p_wxICOHandler,
22224 &_swigt__p_wxIconizeEvent,
22225 &_swigt__p_wxIdleEvent,
22226 &_swigt__p_wxImage,
22227 &_swigt__p_wxImageHandler,
22228 &_swigt__p_wxIndividualLayoutConstraint,
22229 &_swigt__p_wxInitDialogEvent,
22230 &_swigt__p_wxJPEGHandler,
22231 &_swigt__p_wxKeyEvent,
22232 &_swigt__p_wxLayoutAlgorithm,
22233 &_swigt__p_wxLayoutConstraints,
22234 &_swigt__p_wxMDIChildFrame,
22235 &_swigt__p_wxMDIClientWindow,
22236 &_swigt__p_wxMDIParentFrame,
22237 &_swigt__p_wxMaximizeEvent,
22238 &_swigt__p_wxMenu,
22239 &_swigt__p_wxMenuBar,
22240 &_swigt__p_wxMenuEvent,
22241 &_swigt__p_wxMenuItem,
22242 &_swigt__p_wxMessageDialog,
22243 &_swigt__p_wxMiniFrame,
22244 &_swigt__p_wxMouseCaptureChangedEvent,
22245 &_swigt__p_wxMouseEvent,
22246 &_swigt__p_wxMoveEvent,
22247 &_swigt__p_wxMultiChoiceDialog,
22248 &_swigt__p_wxNavigationKeyEvent,
22249 &_swigt__p_wxNcPaintEvent,
22250 &_swigt__p_wxNotifyEvent,
22251 &_swigt__p_wxNumberEntryDialog,
22252 &_swigt__p_wxObject,
22253 &_swigt__p_wxPCXHandler,
22254 &_swigt__p_wxPNGHandler,
22255 &_swigt__p_wxPNMHandler,
22256 &_swigt__p_wxPageSetupDialog,
22257 &_swigt__p_wxPageSetupDialogData,
22258 &_swigt__p_wxPaintEvent,
22259 &_swigt__p_wxPaletteChangedEvent,
22260 &_swigt__p_wxPanel,
22261 &_swigt__p_wxPaperSize,
22262 &_swigt__p_wxPasswordEntryDialog,
22263 &_swigt__p_wxPen,
22264 &_swigt__p_wxPoint,
22265 &_swigt__p_wxPopupWindow,
22266 &_swigt__p_wxPreviewCanvas,
22267 &_swigt__p_wxPreviewControlBar,
22268 &_swigt__p_wxPreviewFrame,
22269 &_swigt__p_wxPrintData,
22270 &_swigt__p_wxPrintDialog,
22271 &_swigt__p_wxPrintDialogData,
22272 &_swigt__p_wxPrintPreview,
22273 &_swigt__p_wxPrinter,
22274 &_swigt__p_wxProgressDialog,
22275 &_swigt__p_wxPyApp,
22276 &_swigt__p_wxPyCommandEvent,
22277 &_swigt__p_wxPyEvent,
22278 &_swigt__p_wxPyGridCellAttrProvider,
22279 &_swigt__p_wxPyGridCellEditor,
22280 &_swigt__p_wxPyGridCellRenderer,
22281 &_swigt__p_wxPyGridTableBase,
22282 &_swigt__p_wxPyHtmlListBox,
22283 &_swigt__p_wxPyImageHandler,
22284 &_swigt__p_wxPyPanel,
22285 &_swigt__p_wxPyPopupTransientWindow,
22286 &_swigt__p_wxPyPreviewControlBar,
22287 &_swigt__p_wxPyPreviewFrame,
22288 &_swigt__p_wxPyPrintPreview,
22289 &_swigt__p_wxPyPrintout,
22290 &_swigt__p_wxPyScrolledWindow,
22291 &_swigt__p_wxPySizer,
22292 &_swigt__p_wxPyTaskBarIcon,
22293 &_swigt__p_wxPyVListBox,
22294 &_swigt__p_wxPyVScrolledWindow,
22295 &_swigt__p_wxPyValidator,
22296 &_swigt__p_wxPyWindow,
22297 &_swigt__p_wxQueryLayoutInfoEvent,
22298 &_swigt__p_wxQueryNewPaletteEvent,
22299 &_swigt__p_wxRect,
22300 &_swigt__p_wxSashEvent,
22301 &_swigt__p_wxSashLayoutWindow,
22302 &_swigt__p_wxSashWindow,
22303 &_swigt__p_wxScrollEvent,
22304 &_swigt__p_wxScrollWinEvent,
22305 &_swigt__p_wxScrolledWindow,
22306 &_swigt__p_wxSetCursorEvent,
22307 &_swigt__p_wxShowEvent,
22308 &_swigt__p_wxSingleChoiceDialog,
22309 &_swigt__p_wxSizeEvent,
22310 &_swigt__p_wxSizer,
22311 &_swigt__p_wxSizerItem,
22312 &_swigt__p_wxSplashScreen,
22313 &_swigt__p_wxSplashScreenWindow,
22314 &_swigt__p_wxSplitterEvent,
22315 &_swigt__p_wxSplitterWindow,
22316 &_swigt__p_wxStaticBoxSizer,
22317 &_swigt__p_wxStatusBar,
22318 &_swigt__p_wxStdDialogButtonSizer,
22319 &_swigt__p_wxString,
22320 &_swigt__p_wxSysColourChangedEvent,
22321 &_swigt__p_wxTIFFHandler,
22322 &_swigt__p_wxTaskBarIconEvent,
22323 &_swigt__p_wxTextEntryDialog,
22324 &_swigt__p_wxTipWindow,
22325 &_swigt__p_wxTopLevelWindow,
22326 &_swigt__p_wxUpdateUIEvent,
22327 &_swigt__p_wxValidator,
22328 &_swigt__p_wxVisualAttributes,
22329 &_swigt__p_wxWindow,
22330 &_swigt__p_wxWindowCreateEvent,
22331 &_swigt__p_wxWindowDestroyEvent,
22332 &_swigt__p_wxXPMHandler,
22333 };
22334
22335 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22336 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22337 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22338 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22339 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22340 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22341 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22342 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22343 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22344 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22345 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22346 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22347 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22348 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22349 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22350 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22351 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22352 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22353 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22354 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22355 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22356 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}};
22357 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22358 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}};
22359 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22360 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22361 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22362 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22363 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22364 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22365 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22366 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22367 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22368 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22369 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22370 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22371 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22372 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22373 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22374 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22375 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22376 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22377 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22378 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22379 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22380 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22381 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22382 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22383 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22384 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22385 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22386 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22387 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22388 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22389 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}};
22390 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22391 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22392 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22393 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22394 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22395 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22396 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22397 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22398 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22399 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22400 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22401 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22402 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22403 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22404 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22405 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22406 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22407 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22408 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22409 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22410 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22411 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22412 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22413 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22414 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22415 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22416 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22417 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22418 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22419 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22420 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22421 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22422 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22423 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22424 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22425 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22426 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22427 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22428 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22429 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22430 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22431 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22432 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22433 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22434 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22435 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_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_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_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_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_wxPopupWindow, _p_wxPopupWindowTo_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}};
22436 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22437 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22438 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22439 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}};
22440 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22441 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22442 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22443 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22444 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}};
22445 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22446 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22447 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}};
22448 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22449 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22450 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22451 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22452 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22453 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22454 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}};
22455 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}};
22456 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}};
22457 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}};
22458 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22459 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22460 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22461 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22462 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22463 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}};
22464 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22465 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22466 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}};
22467 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22468 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22469 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22470 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22471 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22472 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22473 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22474 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22475 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22476 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22477 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22478 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22479 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22480 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22481 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22482 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22483 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22484 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22485 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22486 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22487 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22488 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22489 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22490 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22491 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22492 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22493 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22494 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22495 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22496 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22497 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22498 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22499 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22500 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22501 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22502 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22503 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22504 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22505 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22506 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22507 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22508 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22509 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22510 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_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_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_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_wxPNGHandler, _p_wxPNGHandlerTo_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}};
22511 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}};
22512 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22513 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22514 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22515 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22516 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22517 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22518 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22519 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22520 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}};
22521 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22522 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22523 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_wxFileDialog, _p_wxFileDialogTo_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_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_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_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}};
22524
22525 static swig_cast_info *swig_cast_initial[] = {
22526 _swigc__p_char,
22527 _swigc__p_form_ops_t,
22528 _swigc__p_int,
22529 _swigc__p_long,
22530 _swigc__p_unsigned_char,
22531 _swigc__p_unsigned_int,
22532 _swigc__p_unsigned_long,
22533 _swigc__p_wxANIHandler,
22534 _swigc__p_wxAcceleratorTable,
22535 _swigc__p_wxActivateEvent,
22536 _swigc__p_wxArrayString,
22537 _swigc__p_wxBMPHandler,
22538 _swigc__p_wxBoxSizer,
22539 _swigc__p_wxCURHandler,
22540 _swigc__p_wxCalculateLayoutEvent,
22541 _swigc__p_wxChildFocusEvent,
22542 _swigc__p_wxClipboardTextEvent,
22543 _swigc__p_wxCloseEvent,
22544 _swigc__p_wxColour,
22545 _swigc__p_wxColourData,
22546 _swigc__p_wxColourDialog,
22547 _swigc__p_wxCommandEvent,
22548 _swigc__p_wxContextMenuEvent,
22549 _swigc__p_wxControl,
22550 _swigc__p_wxControlWithItems,
22551 _swigc__p_wxDC,
22552 _swigc__p_wxDateEvent,
22553 _swigc__p_wxDialog,
22554 _swigc__p_wxDirDialog,
22555 _swigc__p_wxDisplayChangedEvent,
22556 _swigc__p_wxDropFilesEvent,
22557 _swigc__p_wxDuplexMode,
22558 _swigc__p_wxEraseEvent,
22559 _swigc__p_wxEvent,
22560 _swigc__p_wxEvtHandler,
22561 _swigc__p_wxFSFile,
22562 _swigc__p_wxFileDialog,
22563 _swigc__p_wxFileSystem,
22564 _swigc__p_wxFindDialogEvent,
22565 _swigc__p_wxFindReplaceData,
22566 _swigc__p_wxFindReplaceDialog,
22567 _swigc__p_wxFlexGridSizer,
22568 _swigc__p_wxFocusEvent,
22569 _swigc__p_wxFont,
22570 _swigc__p_wxFontData,
22571 _swigc__p_wxFontDialog,
22572 _swigc__p_wxFrame,
22573 _swigc__p_wxGBSizerItem,
22574 _swigc__p_wxGIFHandler,
22575 _swigc__p_wxGrid,
22576 _swigc__p_wxGridBagSizer,
22577 _swigc__p_wxGridCellAttr,
22578 _swigc__p_wxGridCellAttrProvider,
22579 _swigc__p_wxGridCellAutoWrapStringEditor,
22580 _swigc__p_wxGridCellAutoWrapStringRenderer,
22581 _swigc__p_wxGridCellBoolEditor,
22582 _swigc__p_wxGridCellBoolRenderer,
22583 _swigc__p_wxGridCellChoiceEditor,
22584 _swigc__p_wxGridCellCoords,
22585 _swigc__p_wxGridCellDateTimeRenderer,
22586 _swigc__p_wxGridCellEditor,
22587 _swigc__p_wxGridCellEnumEditor,
22588 _swigc__p_wxGridCellEnumRenderer,
22589 _swigc__p_wxGridCellFloatEditor,
22590 _swigc__p_wxGridCellFloatRenderer,
22591 _swigc__p_wxGridCellNumberEditor,
22592 _swigc__p_wxGridCellNumberRenderer,
22593 _swigc__p_wxGridCellRenderer,
22594 _swigc__p_wxGridCellStringRenderer,
22595 _swigc__p_wxGridCellTextEditor,
22596 _swigc__p_wxGridCellWorker,
22597 _swigc__p_wxGridEditorCreatedEvent,
22598 _swigc__p_wxGridEvent,
22599 _swigc__p_wxGridRangeSelectEvent,
22600 _swigc__p_wxGridSizeEvent,
22601 _swigc__p_wxGridSizer,
22602 _swigc__p_wxGridStringTable,
22603 _swigc__p_wxGridTableBase,
22604 _swigc__p_wxGridTableMessage,
22605 _swigc__p_wxICOHandler,
22606 _swigc__p_wxIconizeEvent,
22607 _swigc__p_wxIdleEvent,
22608 _swigc__p_wxImage,
22609 _swigc__p_wxImageHandler,
22610 _swigc__p_wxIndividualLayoutConstraint,
22611 _swigc__p_wxInitDialogEvent,
22612 _swigc__p_wxJPEGHandler,
22613 _swigc__p_wxKeyEvent,
22614 _swigc__p_wxLayoutAlgorithm,
22615 _swigc__p_wxLayoutConstraints,
22616 _swigc__p_wxMDIChildFrame,
22617 _swigc__p_wxMDIClientWindow,
22618 _swigc__p_wxMDIParentFrame,
22619 _swigc__p_wxMaximizeEvent,
22620 _swigc__p_wxMenu,
22621 _swigc__p_wxMenuBar,
22622 _swigc__p_wxMenuEvent,
22623 _swigc__p_wxMenuItem,
22624 _swigc__p_wxMessageDialog,
22625 _swigc__p_wxMiniFrame,
22626 _swigc__p_wxMouseCaptureChangedEvent,
22627 _swigc__p_wxMouseEvent,
22628 _swigc__p_wxMoveEvent,
22629 _swigc__p_wxMultiChoiceDialog,
22630 _swigc__p_wxNavigationKeyEvent,
22631 _swigc__p_wxNcPaintEvent,
22632 _swigc__p_wxNotifyEvent,
22633 _swigc__p_wxNumberEntryDialog,
22634 _swigc__p_wxObject,
22635 _swigc__p_wxPCXHandler,
22636 _swigc__p_wxPNGHandler,
22637 _swigc__p_wxPNMHandler,
22638 _swigc__p_wxPageSetupDialog,
22639 _swigc__p_wxPageSetupDialogData,
22640 _swigc__p_wxPaintEvent,
22641 _swigc__p_wxPaletteChangedEvent,
22642 _swigc__p_wxPanel,
22643 _swigc__p_wxPaperSize,
22644 _swigc__p_wxPasswordEntryDialog,
22645 _swigc__p_wxPen,
22646 _swigc__p_wxPoint,
22647 _swigc__p_wxPopupWindow,
22648 _swigc__p_wxPreviewCanvas,
22649 _swigc__p_wxPreviewControlBar,
22650 _swigc__p_wxPreviewFrame,
22651 _swigc__p_wxPrintData,
22652 _swigc__p_wxPrintDialog,
22653 _swigc__p_wxPrintDialogData,
22654 _swigc__p_wxPrintPreview,
22655 _swigc__p_wxPrinter,
22656 _swigc__p_wxProgressDialog,
22657 _swigc__p_wxPyApp,
22658 _swigc__p_wxPyCommandEvent,
22659 _swigc__p_wxPyEvent,
22660 _swigc__p_wxPyGridCellAttrProvider,
22661 _swigc__p_wxPyGridCellEditor,
22662 _swigc__p_wxPyGridCellRenderer,
22663 _swigc__p_wxPyGridTableBase,
22664 _swigc__p_wxPyHtmlListBox,
22665 _swigc__p_wxPyImageHandler,
22666 _swigc__p_wxPyPanel,
22667 _swigc__p_wxPyPopupTransientWindow,
22668 _swigc__p_wxPyPreviewControlBar,
22669 _swigc__p_wxPyPreviewFrame,
22670 _swigc__p_wxPyPrintPreview,
22671 _swigc__p_wxPyPrintout,
22672 _swigc__p_wxPyScrolledWindow,
22673 _swigc__p_wxPySizer,
22674 _swigc__p_wxPyTaskBarIcon,
22675 _swigc__p_wxPyVListBox,
22676 _swigc__p_wxPyVScrolledWindow,
22677 _swigc__p_wxPyValidator,
22678 _swigc__p_wxPyWindow,
22679 _swigc__p_wxQueryLayoutInfoEvent,
22680 _swigc__p_wxQueryNewPaletteEvent,
22681 _swigc__p_wxRect,
22682 _swigc__p_wxSashEvent,
22683 _swigc__p_wxSashLayoutWindow,
22684 _swigc__p_wxSashWindow,
22685 _swigc__p_wxScrollEvent,
22686 _swigc__p_wxScrollWinEvent,
22687 _swigc__p_wxScrolledWindow,
22688 _swigc__p_wxSetCursorEvent,
22689 _swigc__p_wxShowEvent,
22690 _swigc__p_wxSingleChoiceDialog,
22691 _swigc__p_wxSizeEvent,
22692 _swigc__p_wxSizer,
22693 _swigc__p_wxSizerItem,
22694 _swigc__p_wxSplashScreen,
22695 _swigc__p_wxSplashScreenWindow,
22696 _swigc__p_wxSplitterEvent,
22697 _swigc__p_wxSplitterWindow,
22698 _swigc__p_wxStaticBoxSizer,
22699 _swigc__p_wxStatusBar,
22700 _swigc__p_wxStdDialogButtonSizer,
22701 _swigc__p_wxString,
22702 _swigc__p_wxSysColourChangedEvent,
22703 _swigc__p_wxTIFFHandler,
22704 _swigc__p_wxTaskBarIconEvent,
22705 _swigc__p_wxTextEntryDialog,
22706 _swigc__p_wxTipWindow,
22707 _swigc__p_wxTopLevelWindow,
22708 _swigc__p_wxUpdateUIEvent,
22709 _swigc__p_wxValidator,
22710 _swigc__p_wxVisualAttributes,
22711 _swigc__p_wxWindow,
22712 _swigc__p_wxWindowCreateEvent,
22713 _swigc__p_wxWindowDestroyEvent,
22714 _swigc__p_wxXPMHandler,
22715 };
22716
22717
22718 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22719
22720 static swig_const_info swig_const_table[] = {
22721 {0, 0, 0, 0.0, 0, 0}};
22722
22723 #ifdef __cplusplus
22724 }
22725 #endif
22726 /* -----------------------------------------------------------------------------
22727 * Type initialization:
22728 * This problem is tough by the requirement that no dynamic
22729 * memory is used. Also, since swig_type_info structures store pointers to
22730 * swig_cast_info structures and swig_cast_info structures store pointers back
22731 * to swig_type_info structures, we need some lookup code at initialization.
22732 * The idea is that swig generates all the structures that are needed.
22733 * The runtime then collects these partially filled structures.
22734 * The SWIG_InitializeModule function takes these initial arrays out of
22735 * swig_module, and does all the lookup, filling in the swig_module.types
22736 * array with the correct data and linking the correct swig_cast_info
22737 * structures together.
22738 *
22739 * The generated swig_type_info structures are assigned staticly to an initial
22740 * array. We just loop though that array, and handle each type individually.
22741 * First we lookup if this type has been already loaded, and if so, use the
22742 * loaded structure instead of the generated one. Then we have to fill in the
22743 * cast linked list. The cast data is initially stored in something like a
22744 * two-dimensional array. Each row corresponds to a type (there are the same
22745 * number of rows as there are in the swig_type_initial array). Each entry in
22746 * a column is one of the swig_cast_info structures for that type.
22747 * The cast_initial array is actually an array of arrays, because each row has
22748 * a variable number of columns. So to actually build the cast linked list,
22749 * we find the array of casts associated with the type, and loop through it
22750 * adding the casts to the list. The one last trick we need to do is making
22751 * sure the type pointer in the swig_cast_info struct is correct.
22752 *
22753 * First off, we lookup the cast->type name to see if it is already loaded.
22754 * There are three cases to handle:
22755 * 1) If the cast->type has already been loaded AND the type we are adding
22756 * casting info to has not been loaded (it is in this module), THEN we
22757 * replace the cast->type pointer with the type pointer that has already
22758 * been loaded.
22759 * 2) If BOTH types (the one we are adding casting info to, and the
22760 * cast->type) are loaded, THEN the cast info has already been loaded by
22761 * the previous module so we just ignore it.
22762 * 3) Finally, if cast->type has not already been loaded, then we add that
22763 * swig_cast_info to the linked list (because the cast->type) pointer will
22764 * be correct.
22765 * ----------------------------------------------------------------------------- */
22766
22767 #ifdef __cplusplus
22768 extern "C" {
22769 #if 0
22770 } /* c-mode */
22771 #endif
22772 #endif
22773
22774 #if 0
22775 #define SWIGRUNTIME_DEBUG
22776 #endif
22777
22778 SWIGRUNTIME void
22779 SWIG_InitializeModule(void *clientdata) {
22780 size_t i;
22781 swig_module_info *module_head;
22782 static int init_run = 0;
22783
22784 clientdata = clientdata;
22785
22786 if (init_run) return;
22787 init_run = 1;
22788
22789 /* Initialize the swig_module */
22790 swig_module.type_initial = swig_type_initial;
22791 swig_module.cast_initial = swig_cast_initial;
22792
22793 /* Try and load any already created modules */
22794 module_head = SWIG_GetModule(clientdata);
22795 if (module_head) {
22796 swig_module.next = module_head->next;
22797 module_head->next = &swig_module;
22798 } else {
22799 /* This is the first module loaded */
22800 swig_module.next = &swig_module;
22801 SWIG_SetModule(clientdata, &swig_module);
22802 }
22803
22804 /* Now work on filling in swig_module.types */
22805 #ifdef SWIGRUNTIME_DEBUG
22806 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22807 #endif
22808 for (i = 0; i < swig_module.size; ++i) {
22809 swig_type_info *type = 0;
22810 swig_type_info *ret;
22811 swig_cast_info *cast;
22812
22813 #ifdef SWIGRUNTIME_DEBUG
22814 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22815 #endif
22816
22817 /* if there is another module already loaded */
22818 if (swig_module.next != &swig_module) {
22819 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22820 }
22821 if (type) {
22822 /* Overwrite clientdata field */
22823 #ifdef SWIGRUNTIME_DEBUG
22824 printf("SWIG_InitializeModule: found type %s\n", type->name);
22825 #endif
22826 if (swig_module.type_initial[i]->clientdata) {
22827 type->clientdata = swig_module.type_initial[i]->clientdata;
22828 #ifdef SWIGRUNTIME_DEBUG
22829 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22830 #endif
22831 }
22832 } else {
22833 type = swig_module.type_initial[i];
22834 }
22835
22836 /* Insert casting types */
22837 cast = swig_module.cast_initial[i];
22838 while (cast->type) {
22839 /* Don't need to add information already in the list */
22840 ret = 0;
22841 #ifdef SWIGRUNTIME_DEBUG
22842 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22843 #endif
22844 if (swig_module.next != &swig_module) {
22845 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22846 #ifdef SWIGRUNTIME_DEBUG
22847 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22848 #endif
22849 }
22850 if (ret) {
22851 if (type == swig_module.type_initial[i]) {
22852 #ifdef SWIGRUNTIME_DEBUG
22853 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22854 #endif
22855 cast->type = ret;
22856 ret = 0;
22857 } else {
22858 /* Check for casting already in the list */
22859 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22860 #ifdef SWIGRUNTIME_DEBUG
22861 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22862 #endif
22863 if (!ocast) ret = 0;
22864 }
22865 }
22866
22867 if (!ret) {
22868 #ifdef SWIGRUNTIME_DEBUG
22869 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22870 #endif
22871 if (type->cast) {
22872 type->cast->prev = cast;
22873 cast->next = type->cast;
22874 }
22875 type->cast = cast;
22876 }
22877 cast++;
22878 }
22879 /* Set entry in modules->types array equal to the type */
22880 swig_module.types[i] = type;
22881 }
22882 swig_module.types[i] = 0;
22883
22884 #ifdef SWIGRUNTIME_DEBUG
22885 printf("**** SWIG_InitializeModule: Cast List ******\n");
22886 for (i = 0; i < swig_module.size; ++i) {
22887 int j = 0;
22888 swig_cast_info *cast = swig_module.cast_initial[i];
22889 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22890 while (cast->type) {
22891 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22892 cast++;
22893 ++j;
22894 }
22895 printf("---- Total casts: %d\n",j);
22896 }
22897 printf("**** SWIG_InitializeModule: Cast List ******\n");
22898 #endif
22899 }
22900
22901 /* This function will propagate the clientdata field of type to
22902 * any new swig_type_info structures that have been added into the list
22903 * of equivalent types. It is like calling
22904 * SWIG_TypeClientData(type, clientdata) a second time.
22905 */
22906 SWIGRUNTIME void
22907 SWIG_PropagateClientData(void) {
22908 size_t i;
22909 swig_cast_info *equiv;
22910 static int init_run = 0;
22911
22912 if (init_run) return;
22913 init_run = 1;
22914
22915 for (i = 0; i < swig_module.size; i++) {
22916 if (swig_module.types[i]->clientdata) {
22917 equiv = swig_module.types[i]->cast;
22918 while (equiv) {
22919 if (!equiv->converter) {
22920 if (equiv->type && !equiv->type->clientdata)
22921 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22922 }
22923 equiv = equiv->next;
22924 }
22925 }
22926 }
22927 }
22928
22929 #ifdef __cplusplus
22930 #if 0
22931 {
22932 /* c-mode */
22933 #endif
22934 }
22935 #endif
22936
22937
22938
22939 #ifdef __cplusplus
22940 extern "C" {
22941 #endif
22942
22943 /* Python-specific SWIG API */
22944 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22945 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22946 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22947
22948 /* -----------------------------------------------------------------------------
22949 * global variable support code.
22950 * ----------------------------------------------------------------------------- */
22951
22952 typedef struct swig_globalvar {
22953 char *name; /* Name of global variable */
22954 PyObject *(*get_attr)(void); /* Return the current value */
22955 int (*set_attr)(PyObject *); /* Set the value */
22956 struct swig_globalvar *next;
22957 } swig_globalvar;
22958
22959 typedef struct swig_varlinkobject {
22960 PyObject_HEAD
22961 swig_globalvar *vars;
22962 } swig_varlinkobject;
22963
22964 SWIGINTERN PyObject *
22965 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22966 return PyString_FromString("<Swig global variables>");
22967 }
22968
22969 SWIGINTERN PyObject *
22970 swig_varlink_str(swig_varlinkobject *v) {
22971 PyObject *str = PyString_FromString("(");
22972 swig_globalvar *var;
22973 for (var = v->vars; var; var=var->next) {
22974 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22975 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22976 }
22977 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22978 return str;
22979 }
22980
22981 SWIGINTERN int
22982 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22983 PyObject *str = swig_varlink_str(v);
22984 fprintf(fp,"Swig global variables ");
22985 fprintf(fp,"%s\n", PyString_AsString(str));
22986 Py_DECREF(str);
22987 return 0;
22988 }
22989
22990 SWIGINTERN void
22991 swig_varlink_dealloc(swig_varlinkobject *v) {
22992 swig_globalvar *var = v->vars;
22993 while (var) {
22994 swig_globalvar *n = var->next;
22995 free(var->name);
22996 free(var);
22997 var = n;
22998 }
22999 }
23000
23001 SWIGINTERN PyObject *
23002 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23003 PyObject *res = NULL;
23004 swig_globalvar *var = v->vars;
23005 while (var) {
23006 if (strcmp(var->name,n) == 0) {
23007 res = (*var->get_attr)();
23008 break;
23009 }
23010 var = var->next;
23011 }
23012 if (res == NULL && !PyErr_Occurred()) {
23013 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23014 }
23015 return res;
23016 }
23017
23018 SWIGINTERN int
23019 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23020 int res = 1;
23021 swig_globalvar *var = v->vars;
23022 while (var) {
23023 if (strcmp(var->name,n) == 0) {
23024 res = (*var->set_attr)(p);
23025 break;
23026 }
23027 var = var->next;
23028 }
23029 if (res == 1 && !PyErr_Occurred()) {
23030 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23031 }
23032 return res;
23033 }
23034
23035 SWIGINTERN PyTypeObject*
23036 swig_varlink_type(void) {
23037 static char varlink__doc__[] = "Swig var link object";
23038 static PyTypeObject varlink_type;
23039 static int type_init = 0;
23040 if (!type_init) {
23041 const PyTypeObject tmp
23042 = {
23043 PyObject_HEAD_INIT(NULL)
23044 0, /* Number of items in variable part (ob_size) */
23045 (char *)"swigvarlink", /* Type name (tp_name) */
23046 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23047 0, /* Itemsize (tp_itemsize) */
23048 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23049 (printfunc) swig_varlink_print, /* Print (tp_print) */
23050 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23051 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23052 0, /* tp_compare */
23053 (reprfunc) swig_varlink_repr, /* tp_repr */
23054 0, /* tp_as_number */
23055 0, /* tp_as_sequence */
23056 0, /* tp_as_mapping */
23057 0, /* tp_hash */
23058 0, /* tp_call */
23059 (reprfunc)swig_varlink_str, /* tp_str */
23060 0, /* tp_getattro */
23061 0, /* tp_setattro */
23062 0, /* tp_as_buffer */
23063 0, /* tp_flags */
23064 varlink__doc__, /* tp_doc */
23065 0, /* tp_traverse */
23066 0, /* tp_clear */
23067 0, /* tp_richcompare */
23068 0, /* tp_weaklistoffset */
23069 #if PY_VERSION_HEX >= 0x02020000
23070 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23071 #endif
23072 #if PY_VERSION_HEX >= 0x02030000
23073 0, /* tp_del */
23074 #endif
23075 #ifdef COUNT_ALLOCS
23076 0,0,0,0 /* tp_alloc -> tp_next */
23077 #endif
23078 };
23079 varlink_type = tmp;
23080 varlink_type.ob_type = &PyType_Type;
23081 type_init = 1;
23082 }
23083 return &varlink_type;
23084 }
23085
23086 /* Create a variable linking object for use later */
23087 SWIGINTERN PyObject *
23088 SWIG_Python_newvarlink(void) {
23089 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23090 if (result) {
23091 result->vars = 0;
23092 }
23093 return ((PyObject*) result);
23094 }
23095
23096 SWIGINTERN void
23097 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23098 swig_varlinkobject *v = (swig_varlinkobject *) p;
23099 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23100 if (gv) {
23101 size_t size = strlen(name)+1;
23102 gv->name = (char *)malloc(size);
23103 if (gv->name) {
23104 strncpy(gv->name,name,size);
23105 gv->get_attr = get_attr;
23106 gv->set_attr = set_attr;
23107 gv->next = v->vars;
23108 }
23109 }
23110 v->vars = gv;
23111 }
23112
23113 SWIGINTERN PyObject *
23114 SWIG_globals() {
23115 static PyObject *_SWIG_globals = 0;
23116 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23117 return _SWIG_globals;
23118 }
23119
23120 /* -----------------------------------------------------------------------------
23121 * constants/methods manipulation
23122 * ----------------------------------------------------------------------------- */
23123
23124 /* Install Constants */
23125 SWIGINTERN void
23126 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23127 PyObject *obj = 0;
23128 size_t i;
23129 for (i = 0; constants[i].type; ++i) {
23130 switch(constants[i].type) {
23131 case SWIG_PY_POINTER:
23132 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23133 break;
23134 case SWIG_PY_BINARY:
23135 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23136 break;
23137 default:
23138 obj = 0;
23139 break;
23140 }
23141 if (obj) {
23142 PyDict_SetItemString(d, constants[i].name, obj);
23143 Py_DECREF(obj);
23144 }
23145 }
23146 }
23147
23148 /* -----------------------------------------------------------------------------*/
23149 /* Fix SwigMethods to carry the callback ptrs when needed */
23150 /* -----------------------------------------------------------------------------*/
23151
23152 SWIGINTERN void
23153 SWIG_Python_FixMethods(PyMethodDef *methods,
23154 swig_const_info *const_table,
23155 swig_type_info **types,
23156 swig_type_info **types_initial) {
23157 size_t i;
23158 for (i = 0; methods[i].ml_name; ++i) {
23159 const char *c = methods[i].ml_doc;
23160 if (c && (c = strstr(c, "swig_ptr: "))) {
23161 int j;
23162 swig_const_info *ci = 0;
23163 const char *name = c + 10;
23164 for (j = 0; const_table[j].type; ++j) {
23165 if (strncmp(const_table[j].name, name,
23166 strlen(const_table[j].name)) == 0) {
23167 ci = &(const_table[j]);
23168 break;
23169 }
23170 }
23171 if (ci) {
23172 size_t shift = (ci->ptype) - types;
23173 swig_type_info *ty = types_initial[shift];
23174 size_t ldoc = (c - methods[i].ml_doc);
23175 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23176 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23177 if (ndoc) {
23178 char *buff = ndoc;
23179 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23180 if (ptr) {
23181 strncpy(buff, methods[i].ml_doc, ldoc);
23182 buff += ldoc;
23183 strncpy(buff, "swig_ptr: ", 10);
23184 buff += 10;
23185 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23186 methods[i].ml_doc = ndoc;
23187 }
23188 }
23189 }
23190 }
23191 }
23192 }
23193
23194 #ifdef __cplusplus
23195 }
23196 #endif
23197
23198 /* -----------------------------------------------------------------------------*
23199 * Partial Init method
23200 * -----------------------------------------------------------------------------*/
23201
23202 #ifdef __cplusplus
23203 extern "C"
23204 #endif
23205 SWIGEXPORT void SWIG_init(void) {
23206 PyObject *m, *d;
23207
23208 /* Fix SwigMethods to carry the callback ptrs when needed */
23209 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23210
23211 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23212 d = PyModule_GetDict(m);
23213
23214 SWIG_InitializeModule(0);
23215 SWIG_InstallConstants(d,swig_const_table);
23216
23217
23218 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23219 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23220 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23221 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23222 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23223 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23224 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23225 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23226 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23227 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23228 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23229 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23230 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23231 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23232 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23233 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23234 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23235 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23236 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23237 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23238 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23239 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23240 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23241 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23242 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23243 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23244 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23245 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23246 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23247 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23248 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23249 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23250 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23251 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23252 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23253 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23254 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23255 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23256 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23257 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23258 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23259 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23260 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23261 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23262 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23263 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23264 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23265 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23266 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23267 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23268 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23269 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23270 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23271 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23272 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23273 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23274
23275
23276 }
23277
wxWidgets (Impactor)