]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added support for drop down toolbar buttons (patch 1713470)
[wxWidgets.git] / wxPython / src / gtk / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #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_wxEventBlocker swig_types[34]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[35]
2502 #define SWIGTYPE_p_wxFSFile swig_types[36]
2503 #define SWIGTYPE_p_wxFileDialog swig_types[37]
2504 #define SWIGTYPE_p_wxFileSystem swig_types[38]
2505 #define SWIGTYPE_p_wxFindDialogEvent swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceData swig_types[40]
2507 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[41]
2508 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2509 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2510 #define SWIGTYPE_p_wxFont swig_types[44]
2511 #define SWIGTYPE_p_wxFontData swig_types[45]
2512 #define SWIGTYPE_p_wxFontDialog swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2516 #define SWIGTYPE_p_wxGrid swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttr swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellCoords swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[70]
2537 #define SWIGTYPE_p_wxGridCellWorker swig_types[71]
2538 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizeEvent swig_types[75]
2542 #define SWIGTYPE_p_wxGridSizer swig_types[76]
2543 #define SWIGTYPE_p_wxGridStringTable swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableBase swig_types[78]
2545 #define SWIGTYPE_p_wxGridTableMessage swig_types[79]
2546 #define SWIGTYPE_p_wxGridUpdateLocker swig_types[80]
2547 #define SWIGTYPE_p_wxICOHandler swig_types[81]
2548 #define SWIGTYPE_p_wxIconizeEvent swig_types[82]
2549 #define SWIGTYPE_p_wxIdleEvent swig_types[83]
2550 #define SWIGTYPE_p_wxImage swig_types[84]
2551 #define SWIGTYPE_p_wxImageHandler swig_types[85]
2552 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[86]
2553 #define SWIGTYPE_p_wxInitDialogEvent swig_types[87]
2554 #define SWIGTYPE_p_wxJPEGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxKeyEvent swig_types[89]
2556 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[90]
2557 #define SWIGTYPE_p_wxLayoutConstraints swig_types[91]
2558 #define SWIGTYPE_p_wxMDIChildFrame swig_types[92]
2559 #define SWIGTYPE_p_wxMDIClientWindow swig_types[93]
2560 #define SWIGTYPE_p_wxMDIParentFrame swig_types[94]
2561 #define SWIGTYPE_p_wxMaximizeEvent swig_types[95]
2562 #define SWIGTYPE_p_wxMenu swig_types[96]
2563 #define SWIGTYPE_p_wxMenuBar swig_types[97]
2564 #define SWIGTYPE_p_wxMenuEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMenuItem swig_types[99]
2566 #define SWIGTYPE_p_wxMessageDialog swig_types[100]
2567 #define SWIGTYPE_p_wxMiniFrame swig_types[101]
2568 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMouseEvent swig_types[104]
2571 #define SWIGTYPE_p_wxMoveEvent swig_types[105]
2572 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[106]
2573 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNcPaintEvent swig_types[108]
2575 #define SWIGTYPE_p_wxNotifyEvent swig_types[109]
2576 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[110]
2577 #define SWIGTYPE_p_wxObject swig_types[111]
2578 #define SWIGTYPE_p_wxPCXHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPNGHandler swig_types[113]
2580 #define SWIGTYPE_p_wxPNMHandler swig_types[114]
2581 #define SWIGTYPE_p_wxPageSetupDialog swig_types[115]
2582 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[116]
2583 #define SWIGTYPE_p_wxPaintEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPanel swig_types[119]
2586 #define SWIGTYPE_p_wxPaperSize swig_types[120]
2587 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[121]
2588 #define SWIGTYPE_p_wxPen swig_types[122]
2589 #define SWIGTYPE_p_wxPoint swig_types[123]
2590 #define SWIGTYPE_p_wxPopupWindow swig_types[124]
2591 #define SWIGTYPE_p_wxPreviewCanvas swig_types[125]
2592 #define SWIGTYPE_p_wxPreviewControlBar swig_types[126]
2593 #define SWIGTYPE_p_wxPreviewFrame swig_types[127]
2594 #define SWIGTYPE_p_wxPrintData swig_types[128]
2595 #define SWIGTYPE_p_wxPrintDialog swig_types[129]
2596 #define SWIGTYPE_p_wxPrintDialogData swig_types[130]
2597 #define SWIGTYPE_p_wxPrintPreview swig_types[131]
2598 #define SWIGTYPE_p_wxPrinter swig_types[132]
2599 #define SWIGTYPE_p_wxProgressDialog swig_types[133]
2600 #define SWIGTYPE_p_wxPyApp swig_types[134]
2601 #define SWIGTYPE_p_wxPyCommandEvent swig_types[135]
2602 #define SWIGTYPE_p_wxPyEvent swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[137]
2604 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[138]
2605 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[139]
2606 #define SWIGTYPE_p_wxPyGridTableBase swig_types[140]
2607 #define SWIGTYPE_p_wxPyHScrolledWindow swig_types[141]
2608 #define SWIGTYPE_p_wxPyHVScrolledWindow swig_types[142]
2609 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[143]
2610 #define SWIGTYPE_p_wxPyImageHandler swig_types[144]
2611 #define SWIGTYPE_p_wxPyPanel swig_types[145]
2612 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[146]
2613 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[147]
2614 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[148]
2615 #define SWIGTYPE_p_wxPyPrintPreview swig_types[149]
2616 #define SWIGTYPE_p_wxPyPrintout swig_types[150]
2617 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[151]
2618 #define SWIGTYPE_p_wxPySizer swig_types[152]
2619 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[153]
2620 #define SWIGTYPE_p_wxPyVListBox swig_types[154]
2621 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[155]
2622 #define SWIGTYPE_p_wxPyValidator swig_types[156]
2623 #define SWIGTYPE_p_wxPyWindow swig_types[157]
2624 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[158]
2625 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[159]
2626 #define SWIGTYPE_p_wxRect swig_types[160]
2627 #define SWIGTYPE_p_wxSashEvent swig_types[161]
2628 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[162]
2629 #define SWIGTYPE_p_wxSashWindow swig_types[163]
2630 #define SWIGTYPE_p_wxScrollEvent swig_types[164]
2631 #define SWIGTYPE_p_wxScrollWinEvent swig_types[165]
2632 #define SWIGTYPE_p_wxScrolledWindow swig_types[166]
2633 #define SWIGTYPE_p_wxSetCursorEvent swig_types[167]
2634 #define SWIGTYPE_p_wxShowEvent swig_types[168]
2635 #define SWIGTYPE_p_wxSimpleHtmlListBox swig_types[169]
2636 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[170]
2637 #define SWIGTYPE_p_wxSize swig_types[171]
2638 #define SWIGTYPE_p_wxSizeEvent swig_types[172]
2639 #define SWIGTYPE_p_wxSizer swig_types[173]
2640 #define SWIGTYPE_p_wxSizerItem swig_types[174]
2641 #define SWIGTYPE_p_wxSplashScreen swig_types[175]
2642 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[176]
2643 #define SWIGTYPE_p_wxSplitterEvent swig_types[177]
2644 #define SWIGTYPE_p_wxSplitterWindow swig_types[178]
2645 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[179]
2646 #define SWIGTYPE_p_wxStatusBar swig_types[180]
2647 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[181]
2648 #define SWIGTYPE_p_wxString swig_types[182]
2649 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[183]
2650 #define SWIGTYPE_p_wxTGAHandler swig_types[184]
2651 #define SWIGTYPE_p_wxTIFFHandler swig_types[185]
2652 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[186]
2653 #define SWIGTYPE_p_wxTextEntryDialog swig_types[187]
2654 #define SWIGTYPE_p_wxTipWindow swig_types[188]
2655 #define SWIGTYPE_p_wxTopLevelWindow swig_types[189]
2656 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[190]
2657 #define SWIGTYPE_p_wxValidator swig_types[191]
2658 #define SWIGTYPE_p_wxVisualAttributes swig_types[192]
2659 #define SWIGTYPE_p_wxWindow swig_types[193]
2660 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[194]
2661 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[195]
2662 #define SWIGTYPE_p_wxXPMHandler swig_types[196]
2663 static swig_type_info *swig_types[198];
2664 static swig_module_info swig_module = {swig_types, 197, 0, 0, 0, 0};
2665 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2666 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2667
2668 /* -------- TYPES TABLE (END) -------- */
2669
2670 #if (PY_VERSION_HEX <= 0x02000000)
2671 # if !defined(SWIG_PYTHON_CLASSIC)
2672 # error "This python version requires to use swig with the '-classic' option"
2673 # endif
2674 #endif
2675 #if (PY_VERSION_HEX <= 0x02020000)
2676 # error "This python version requires to use swig with the '-nomodern' option"
2677 #endif
2678 #if (PY_VERSION_HEX <= 0x02020000)
2679 # error "This python version requires to use swig with the '-nomodernargs' option"
2680 #endif
2681 #ifndef METH_O
2682 # error "This python version requires to use swig with the '-nofastunpack' option"
2683 #endif
2684
2685 /*-----------------------------------------------
2686 @(target):= _grid.so
2687 ------------------------------------------------*/
2688 #define SWIG_init init_grid
2689
2690 #define SWIG_name "_grid"
2691
2692 #define SWIGVERSION 0x010329
2693
2694
2695 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2696 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2697
2698
2699 #include <stdexcept>
2700
2701
2702 namespace swig {
2703 class PyObject_ptr {
2704 protected:
2705 PyObject *_obj;
2706
2707 public:
2708 PyObject_ptr() :_obj(0)
2709 {
2710 }
2711
2712 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2713 {
2714 Py_XINCREF(_obj);
2715 }
2716
2717 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2718 {
2719 if (initial_ref) Py_XINCREF(_obj);
2720 }
2721
2722 PyObject_ptr & operator=(const PyObject_ptr& item)
2723 {
2724 Py_XINCREF(item._obj);
2725 Py_XDECREF(_obj);
2726 _obj = item._obj;
2727 return *this;
2728 }
2729
2730 ~PyObject_ptr()
2731 {
2732 Py_XDECREF(_obj);
2733 }
2734
2735 operator PyObject *() const
2736 {
2737 return _obj;
2738 }
2739
2740 PyObject *operator->() const
2741 {
2742 return _obj;
2743 }
2744 };
2745 }
2746
2747
2748 namespace swig {
2749 struct PyObject_var : PyObject_ptr {
2750 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2751
2752 PyObject_var & operator = (PyObject* obj)
2753 {
2754 Py_XDECREF(_obj);
2755 _obj = obj;
2756 return *this;
2757 }
2758 };
2759 }
2760
2761
2762 #include "wx/wxPython/wxPython.h"
2763 #include "wx/wxPython/pyclasses.h"
2764 #include "wx/wxPython/printfw.h"
2765
2766 #include <wx/grid.h>
2767 #include <wx/generic/gridctrl.h>
2768
2769
2770 static const wxString wxPyEmptyString(wxEmptyString);
2771 static const wxString wxPyGridNameStr(wxGridNameStr);
2772 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2773
2774
2775 #define wxPyMake_TEMPLATE(TYPE) \
2776 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2777 PyObject* target = NULL; \
2778 if (source) { \
2779 /* Check if there is already a pointer to a Python object in the \
2780 OOR data that we can use. */ \
2781 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2782 if (data) { \
2783 target = data->m_obj; \
2784 if (target) \
2785 Py_INCREF(target); \
2786 } \
2787 /* Otherwise make a new wrapper for it the old fashioned way and \
2788 give it the OOR treatment */ \
2789 if (! target) { \
2790 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2791 if (target) \
2792 source->SetClientObject(new wxPyOORClientData(target)); \
2793 } \
2794 } else { /* source was NULL so return None. */ \
2795 Py_INCREF(Py_None); target = Py_None; \
2796 } \
2797 return target; \
2798 } \
2799
2800
2801 wxPyMake_TEMPLATE(wxGridCellRenderer)
2802 wxPyMake_TEMPLATE(wxGridCellEditor)
2803 wxPyMake_TEMPLATE(wxGridCellAttr)
2804 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2805 wxPyMake_TEMPLATE(wxGridTableBase)
2806
2807
2808
2809 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2810 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2811 wxGridCellAttr* rval = NULL; \
2812 bool found; \
2813 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2814 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2815 PyObject* ro; \
2816 wxGridCellAttr* ptr; \
2817 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2818 if (ro) { \
2819 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2820 rval = ptr; \
2821 Py_DECREF(ro); \
2822 } \
2823 } \
2824 wxPyEndBlockThreads(blocked); \
2825 if (! found) \
2826 rval = PCLASS::CBNAME(a, b, c); \
2827 return rval; \
2828 }
2829
2830
2831 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2832 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2833 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2834 bool found; \
2835 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2836 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2837 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2838 Py_DECREF(obj); \
2839 } \
2840 wxPyEndBlockThreads(blocked); \
2841 if (! found) \
2842 PCLASS::CBNAME(attr, a, b); \
2843 }
2844
2845
2846
2847 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2848 void CBNAME(wxGridCellAttr *attr, int val) { \
2849 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2850 bool found; \
2851 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2852 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2853 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2854 Py_DECREF(obj); \
2855 } \
2856 wxPyEndBlockThreads(blocked); \
2857 if (! found) \
2858 PCLASS::CBNAME(attr, val); \
2859 }
2860
2861
2862
2863 #define PYCALLBACK_INT__pure(CBNAME) \
2864 int CBNAME() { \
2865 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2866 int rval = 0; \
2867 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2868 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2869 wxPyEndBlockThreads(blocked); \
2870 return rval; \
2871 }
2872
2873
2874
2875 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2876 bool CBNAME(int a, int b) { \
2877 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2878 bool rval = 0; \
2879 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2880 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2881 wxPyEndBlockThreads(blocked); \
2882 return rval; \
2883 }
2884
2885
2886 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2887 wxString CBNAME(int a, int b) { \
2888 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2889 wxString rval; \
2890 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2891 PyObject* ro; \
2892 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2893 if (ro) { \
2894 rval = Py2wxString(ro); \
2895 Py_DECREF(ro); \
2896 } \
2897 } \
2898 wxPyEndBlockThreads(blocked); \
2899 return rval; \
2900 }
2901
2902
2903 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2904 void CBNAME(int a, int b, const wxString& c) { \
2905 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2906 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2907 PyObject* s = wx2PyString(c); \
2908 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2909 Py_DECREF(s); \
2910 } \
2911 wxPyEndBlockThreads(blocked); \
2912 }
2913
2914
2915 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2916 wxString CBNAME(int a, int b) { \
2917 bool found; \
2918 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2919 wxString rval; \
2920 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2921 PyObject* ro; \
2922 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2923 if (ro) { \
2924 rval = Py2wxString(ro); \
2925 Py_DECREF(ro); \
2926 } \
2927 } \
2928 wxPyEndBlockThreads(blocked); \
2929 if (! found) \
2930 rval = PCLASS::CBNAME(a, b); \
2931 return rval; \
2932 }
2933
2934
2935 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2936 bool CBNAME(int a, int b, const wxString& c) { \
2937 bool rval = 0; \
2938 bool found; \
2939 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2940 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2941 PyObject* s = wx2PyString(c); \
2942 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2943 Py_DECREF(s); \
2944 } \
2945 wxPyEndBlockThreads(blocked); \
2946 if (! found) \
2947 rval = PCLASS::CBNAME(a,b,c); \
2948 return rval; \
2949 }
2950
2951
2952
2953
2954 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2955 long CBNAME(int a, int b) { \
2956 long rval; \
2957 bool found; \
2958 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2959 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2960 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2961 wxPyEndBlockThreads(blocked); \
2962 if (! found) \
2963 rval = PCLASS::CBNAME(a,b); \
2964 return rval; \
2965 }
2966
2967
2968 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2969 bool CBNAME(int a, int b) { \
2970 bool rval = 0; \
2971 bool found; \
2972 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2973 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2974 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2975 wxPyEndBlockThreads(blocked); \
2976 if (! found) \
2977 rval = PCLASS::CBNAME(a,b); \
2978 return rval; \
2979 }
2980
2981
2982
2983 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2984 double CBNAME(int a, int b) { \
2985 bool found; \
2986 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2987 double rval; \
2988 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2989 PyObject* ro; \
2990 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2991 if (ro) { \
2992 PyObject* str = PyObject_Str(ro); \
2993 rval = PyFloat_AsDouble(str); \
2994 Py_DECREF(ro); Py_DECREF(str); \
2995 } \
2996 } \
2997 wxPyEndBlockThreads(blocked); \
2998 if (! found) \
2999 rval = PCLASS::CBNAME(a, b); \
3000 return rval; \
3001 }
3002
3003
3004
3005 #define PYCALLBACK__(PCLASS, CBNAME) \
3006 void CBNAME() { \
3007 bool found; \
3008 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3009 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3010 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3011 wxPyEndBlockThreads(blocked); \
3012 if (! found) \
3013 PCLASS::CBNAME(); \
3014 }
3015
3016
3017
3018 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3019 bool CBNAME(size_t a, size_t b) { \
3020 bool rval = 0; \
3021 bool found; \
3022 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3023 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3024 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3025 wxPyEndBlockThreads(blocked); \
3026 if (! found) \
3027 rval = PCLASS::CBNAME(a,b); \
3028 return rval; \
3029 }
3030
3031
3032
3033 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3034 bool CBNAME(size_t a) { \
3035 bool rval = 0; \
3036 bool found; \
3037 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3038 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3039 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3040 wxPyEndBlockThreads(blocked); \
3041 if (! found) \
3042 rval = PCLASS::CBNAME(a); \
3043 return rval; \
3044 }
3045
3046
3047 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3048 wxString CBNAME(int a) { \
3049 bool found; \
3050 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3051 wxString rval; \
3052 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3053 PyObject* ro; \
3054 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3055 if (ro) { \
3056 rval = Py2wxString(ro); \
3057 Py_DECREF(ro); \
3058 } \
3059 } \
3060 wxPyEndBlockThreads(blocked); \
3061 if (! found) \
3062 rval = PCLASS::CBNAME(a); \
3063 return rval; \
3064 }
3065
3066
3067 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3068 void CBNAME(int a, const wxString& c) { \
3069 bool found; \
3070 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3071 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3072 PyObject* s = wx2PyString(c); \
3073 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3074 Py_DECREF(s); \
3075 } \
3076 wxPyEndBlockThreads(blocked); \
3077 if (! found) \
3078 PCLASS::CBNAME(a,c); \
3079 }
3080
3081
3082
3083
3084 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3085 bool CBNAME() { \
3086 bool rval = 0; \
3087 bool found; \
3088 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3089 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3090 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3091 wxPyEndBlockThreads(blocked); \
3092 if (! found) \
3093 rval = PCLASS::CBNAME(); \
3094 return rval; \
3095 }
3096
3097
3098
3099 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3100 void CBNAME(size_t a, int b) { \
3101 bool found; \
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3103 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3104 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3105 wxPyEndBlockThreads(blocked); \
3106 if (! found) \
3107 PCLASS::CBNAME(a,b); \
3108 }
3109
3110
3111
3112
3113 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3114 void CBNAME(int a, int b, long c) { \
3115 bool found; \
3116 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3117 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3118 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3119 wxPyEndBlockThreads(blocked); \
3120 if (! found) \
3121 PCLASS::CBNAME(a,b,c); \
3122 }
3123
3124
3125
3126
3127 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3128 void CBNAME(int a, int b, double c) { \
3129 bool found; \
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3131 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3132 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3133 wxPyEndBlockThreads(blocked); \
3134 if (! found) \
3135 PCLASS::CBNAME(a,b,c); \
3136 }
3137
3138
3139
3140 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3141 void CBNAME(int a, int b, bool c) { \
3142 bool found; \
3143 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3144 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3145 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3146 wxPyEndBlockThreads(blocked); \
3147 if (! found) \
3148 PCLASS::CBNAME(a,b,c); \
3149 }
3150
3151
3152
3153
3154
3155 SWIGINTERN swig_type_info*
3156 SWIG_pchar_descriptor()
3157 {
3158 static int init = 0;
3159 static swig_type_info* info = 0;
3160 if (!init) {
3161 info = SWIG_TypeQuery("_p_char");
3162 init = 1;
3163 }
3164 return info;
3165 }
3166
3167
3168 SWIGINTERNINLINE PyObject *
3169 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3170 {
3171 if (carray) {
3172 if (size > INT_MAX) {
3173 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3174 return pchar_descriptor ?
3175 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3176 } else {
3177 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3178 }
3179 } else {
3180 return SWIG_Py_Void();
3181 }
3182 }
3183
3184
3185 SWIGINTERNINLINE PyObject *
3186 SWIG_FromCharPtr(const char *cptr)
3187 {
3188 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3189 }
3190
3191
3192 #define SWIG_From_long PyInt_FromLong
3193
3194
3195 SWIGINTERNINLINE PyObject *
3196 SWIG_From_int (int value)
3197 {
3198 return SWIG_From_long (value);
3199 }
3200
3201
3202 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3203 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3204 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3205 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3206 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3207 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3208 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3209 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3210 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3211 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3212
3213 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3214 if (!self->GetClientObject())
3215 self->SetClientObject(new wxPyOORClientData(_self));
3216 }
3217 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3218 }
3219
3220 #include <limits.h>
3221 #ifndef LLONG_MIN
3222 # define LLONG_MIN LONG_LONG_MIN
3223 #endif
3224 #ifndef LLONG_MAX
3225 # define LLONG_MAX LONG_LONG_MAX
3226 #endif
3227 #ifndef ULLONG_MAX
3228 # define ULLONG_MAX ULONG_LONG_MAX
3229 #endif
3230
3231
3232 SWIGINTERN int
3233 SWIG_AsVal_long (PyObject* obj, long* val)
3234 {
3235 if (PyNumber_Check(obj)) {
3236 if (val) *val = PyInt_AsLong(obj);
3237 return SWIG_OK;
3238 }
3239 return SWIG_TypeError;
3240 }
3241
3242
3243 SWIGINTERN int
3244 SWIG_AsVal_int (PyObject * obj, int *val)
3245 {
3246 long v;
3247 int res = SWIG_AsVal_long (obj, &v);
3248 if (SWIG_IsOK(res)) {
3249 if ((v < INT_MIN || v > INT_MAX)) {
3250 return SWIG_OverflowError;
3251 } else {
3252 if (val) *val = static_cast< int >(v);
3253 }
3254 }
3255 return res;
3256 }
3257
3258
3259 SWIGINTERN int
3260 SWIG_AsVal_bool (PyObject *obj, bool *val)
3261 {
3262 if (obj == Py_True) {
3263 if (val) *val = true;
3264 return SWIG_OK;
3265 } else if (obj == Py_False) {
3266 if (val) *val = false;
3267 return SWIG_OK;
3268 } else {
3269 long v = 0;
3270 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3271 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3272 return res;
3273 }
3274 }
3275
3276
3277 class wxPyGridCellRenderer : public wxGridCellRenderer
3278 {
3279 public:
3280 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3281
3282 // Implement Python callback aware virtual methods
3283 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3284 wxDC& dc, const wxRect& rect,
3285 int row, int col, bool isSelected) {
3286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3287 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3288 PyObject* go = wxPyMake_wxObject(&grid,false);
3289 PyObject* dco = wxPyMake_wxObject(&dc,false);
3290 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3291 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3292
3293 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3294 row, col, isSelected));
3295 Py_DECREF(go);
3296 Py_DECREF(ao);
3297 Py_DECREF(dco);
3298 Py_DECREF(ro);
3299 }
3300 wxPyEndBlockThreads(blocked);
3301 }
3302
3303 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3304 int row, int col) {
3305 wxSize rval;
3306 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3307 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3308 PyObject* ro;
3309 wxSize* ptr;
3310 PyObject* go = wxPyMake_wxObject(&grid,false);
3311 PyObject* dco = wxPyMake_wxObject(&dc,false);
3312 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3313
3314 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3315 go, ao, dco,
3316 row, col));
3317 Py_DECREF(go);
3318 Py_DECREF(ao);
3319 Py_DECREF(dco);
3320
3321 if (ro) {
3322 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3323 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3324 rval = *ptr;
3325 }
3326 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3327 PyErr_Clear(); // Clear the exception left over from wxPyConvertSwigPtr
3328 PyObject* o1 = PySequence_GetItem(ro, 0);
3329 PyObject* o2 = PySequence_GetItem(ro, 1);
3330 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3331 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3332 else
3333 PyErr_SetString(PyExc_TypeError, errmsg);
3334 Py_DECREF(o1);
3335 Py_DECREF(o2);
3336 }
3337 else {
3338 PyErr_SetString(PyExc_TypeError, errmsg);
3339 }
3340 Py_DECREF(ro);
3341 }
3342 }
3343 wxPyEndBlockThreads(blocked);
3344 return rval;
3345 }
3346
3347
3348 wxGridCellRenderer *Clone() const {
3349 wxGridCellRenderer* rval = NULL;
3350 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3351 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3352 PyObject* ro;
3353 wxGridCellRenderer* ptr;
3354 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3355 if (ro) {
3356 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3357 rval = ptr;
3358 Py_DECREF(ro);
3359 }
3360 }
3361 wxPyEndBlockThreads(blocked);
3362 return rval;
3363 }
3364
3365 DEC_PYCALLBACK__STRING(SetParameters);
3366
3367 PYPRIVATE;
3368 };
3369
3370 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3371
3372
3373
3374 class wxPyGridCellEditor : public wxGridCellEditor
3375 {
3376 public:
3377 wxPyGridCellEditor() : wxGridCellEditor() {}
3378
3379 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3380 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3381 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3382 PyObject* po = wxPyMake_wxObject(parent,false);
3383 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3384
3385 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3386 Py_DECREF(po);
3387 Py_DECREF(eo);
3388 }
3389 wxPyEndBlockThreads(blocked);
3390 }
3391
3392
3393 void BeginEdit(int row, int col, wxGrid* grid) {
3394 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3395 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3396 PyObject* go = wxPyMake_wxObject(grid,false);
3397 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3398 Py_DECREF(go);
3399 }
3400 wxPyEndBlockThreads(blocked);
3401 }
3402
3403
3404 bool EndEdit(int row, int col, wxGrid* grid) {
3405 bool rv = false;
3406 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3407 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3408 PyObject* go = wxPyMake_wxObject(grid,false);
3409 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3410 Py_DECREF(go);
3411 }
3412 wxPyEndBlockThreads(blocked);
3413 return rv;
3414 }
3415
3416
3417 wxGridCellEditor* Clone() const {
3418 wxGridCellEditor* rval = NULL;
3419 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3420 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3421 PyObject* ro;
3422 wxGridCellEditor* ptr;
3423 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3424 if (ro) {
3425 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3426 rval = ptr;
3427 Py_DECREF(ro);
3428 }
3429 }
3430 wxPyEndBlockThreads(blocked);
3431 return rval;
3432 }
3433
3434
3435 void Show(bool show, wxGridCellAttr *attr) {
3436 bool found;
3437 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3438 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3439 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3440 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3441 Py_DECREF(ao);
3442 }
3443 wxPyEndBlockThreads(blocked);
3444 if (! found)
3445 wxGridCellEditor::Show(show, attr);
3446 }
3447
3448
3449 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3450 bool found;
3451 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3452 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground"))) {
3453 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3454 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3455
3456 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3457
3458 Py_DECREF(ro);
3459 Py_DECREF(ao);
3460 }
3461 wxPyEndBlockThreads(blocked);
3462 if (! found)
3463 wxGridCellEditor::PaintBackground(rectCell, attr);
3464 }
3465
3466
3467 DEC_PYCALLBACK___pure(Reset);
3468 DEC_PYCALLBACK__constany(SetSize, wxRect);
3469 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3470 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3471 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3472 DEC_PYCALLBACK__(StartingClick);
3473 DEC_PYCALLBACK__(Destroy);
3474 DEC_PYCALLBACK__STRING(SetParameters);
3475 DEC_PYCALLBACK_STRING__constpure(GetValue);
3476
3477 PYPRIVATE;
3478 };
3479
3480
3481 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3482 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3483 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3484 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3485 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3486 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3487 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3488 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3489 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3490
3491
3492 static const wxString wxPyOneString(_T("1"));
3493 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3494 if (!self->GetClientObject())
3495 self->SetClientObject(new wxPyOORClientData(_self));
3496 }
3497 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3498 }
3499 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3500 if (!self->GetClientObject())
3501 self->SetClientObject(new wxPyOORClientData(_self));
3502 }
3503
3504 SWIGINTERN int
3505 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3506 {
3507 long v = 0;
3508 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3509 return SWIG_TypeError;
3510 }
3511 else if (val)
3512 *val = (unsigned long)v;
3513 return SWIG_OK;
3514 }
3515
3516
3517 SWIGINTERNINLINE int
3518 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3519 {
3520 unsigned long v;
3521 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3522 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3523 return res;
3524 }
3525
3526
3527 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3528 {
3529 public:
3530 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3531
3532 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3533 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3534 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3535 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3536
3537 PYPRIVATE;
3538 };
3539
3540 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3541 if (!self->GetClientObject())
3542 self->SetClientObject(new wxPyOORClientData(_self));
3543 }
3544
3545 #define SWIG_From_double PyFloat_FromDouble
3546
3547
3548 SWIGINTERN int
3549 SWIG_AsVal_double (PyObject *obj, double* val)
3550 {
3551 if (PyNumber_Check(obj)) {
3552 if (val) *val = PyFloat_AsDouble(obj);
3553 return SWIG_OK;
3554 }
3555 return SWIG_TypeError;
3556 }
3557
3558
3559 class wxPyGridTableBase : public wxGridTableBase
3560 {
3561 public:
3562 wxPyGridTableBase() : wxGridTableBase() {}
3563
3564 PYCALLBACK_INT__pure(GetNumberRows);
3565 PYCALLBACK_INT__pure(GetNumberCols);
3566 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3567 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3568 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3569 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3570 PYCALLBACK__(wxGridTableBase, Clear);
3571 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3572 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3573 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3574 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3575 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3576 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3577 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3578 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3579 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3580 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3581 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3582 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3583 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3584 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3585 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3586
3587
3588 wxString GetValue(int row, int col) {
3589 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3590 wxString rval;
3591 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3592 PyObject* ro;
3593 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3594 if (ro) {
3595 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3596 PyObject* old = ro;
3597 ro = PyObject_Str(ro);
3598 Py_DECREF(old);
3599 }
3600 rval = Py2wxString(ro);
3601 Py_DECREF(ro);
3602 }
3603 }
3604 wxPyEndBlockThreads(blocked);
3605 return rval;
3606 }
3607
3608 void SetValue(int row, int col, const wxString& val) {
3609 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3610 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3611 PyObject* s = wx2PyString(val);
3612 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3613 Py_DECREF(s);
3614 }
3615 wxPyEndBlockThreads(blocked);
3616 }
3617
3618
3619 // Map the Get/Set methods for the standard non-string types to
3620 // the GetValue and SetValue python methods.
3621 long GetValueAsLong( int row, int col ) {
3622 long rval = 0;
3623 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3624 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3625 PyObject* ro;
3626 PyObject* num;
3627 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3628 if (ro && PyNumber_Check(ro)) {
3629 num = PyNumber_Int(ro);
3630 if (num) {
3631 rval = PyInt_AsLong(num);
3632 Py_DECREF(num);
3633 }
3634 Py_DECREF(ro);
3635 }
3636 }
3637 wxPyEndBlockThreads(blocked);
3638 return rval;
3639 }
3640
3641 double GetValueAsDouble( int row, int col ) {
3642 double rval = 0.0;
3643 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3644 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3645 PyObject* ro;
3646 PyObject* num;
3647 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3648 if (ro && PyNumber_Check(ro)) {
3649 num = PyNumber_Float(ro);
3650 if (num) {
3651 rval = PyFloat_AsDouble(num);
3652 Py_DECREF(num);
3653 }
3654 Py_DECREF(ro);
3655 }
3656 }
3657 wxPyEndBlockThreads(blocked);
3658 return rval;
3659 }
3660
3661 bool GetValueAsBool( int row, int col ) {
3662 return (bool)GetValueAsLong(row, col);
3663 }
3664
3665 void SetValueAsLong( int row, int col, long value ) {
3666 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3667 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3668 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3669 }
3670 wxPyEndBlockThreads(blocked);
3671 }
3672
3673 void SetValueAsDouble( int row, int col, double value ) {
3674 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3675 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3676 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3677 }
3678 wxPyEndBlockThreads(blocked);
3679 }
3680
3681 void SetValueAsBool( int row, int col, bool value ) {
3682 SetValueAsLong( row, col, (long)value );
3683 }
3684
3685
3686 PYPRIVATE;
3687 };
3688
3689 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3690
3691 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3692
3693 if (source == Py_None) {
3694 **obj = wxGridCellCoords(-1,-1);
3695 return true;
3696 }
3697
3698 // If source is an object instance then it may already be the right type
3699 if (wxPySwigInstance_Check(source)) {
3700 wxGridCellCoords* ptr;
3701 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3702 goto error;
3703 *obj = ptr;
3704 return true;
3705 }
3706 // otherwise a 2-tuple of integers is expected
3707 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3708 PyObject* o1 = PySequence_GetItem(source, 0);
3709 PyObject* o2 = PySequence_GetItem(source, 1);
3710 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3711 Py_DECREF(o1);
3712 Py_DECREF(o2);
3713 goto error;
3714 }
3715 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3716 Py_DECREF(o1);
3717 Py_DECREF(o2);
3718 return true;
3719 }
3720
3721 error:
3722 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3723 return false;
3724 }
3725
3726
3727 bool wxGridCellCoords_typecheck(PyObject* source) {
3728 void* ptr;
3729
3730 if (wxPySwigInstance_Check(source) &&
3731 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3732 return true;
3733
3734 PyErr_Clear();
3735 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3736 return true;
3737
3738 return false;
3739 }
3740
3741
3742 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3743 {
3744 PyObject* list = PyList_New(0);
3745 size_t idx;
3746 for (idx = 0; idx < source.GetCount(); idx += 1) {
3747 wxGridCellCoords& coord = source.Item(idx);
3748 PyObject* tup = PyTuple_New(2);
3749 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3750 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3751 PyList_Append(list, tup);
3752 Py_DECREF(tup);
3753 }
3754 return list;
3755 }
3756
3757 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3758 wxGridCellCoords temp, *obj = &temp;
3759 if ( other == Py_None ) return false;
3760 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3761 PyErr_Clear();
3762 return false;
3763 }
3764 return self->operator==(*obj);
3765 }
3766 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3767 wxGridCellCoords temp, *obj = &temp;
3768 if ( other == Py_None ) return true;
3769 if ( ! wxGridCellCoords_helper(other, &obj)) {
3770 PyErr_Clear();
3771 return true;
3772 }
3773 return self->operator!=(*obj);
3774 }
3775 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3776 PyObject* tup = PyTuple_New(2);
3777 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3778 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3779 return tup;
3780 }
3781
3782 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3783
3784 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3785 wxGridCellCoords rv;
3786 self->XYToCell(x, y, rv);
3787 return rv;
3788 }
3789 #ifdef __cplusplus
3790 extern "C" {
3791 #endif
3792 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3793 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3794 return 1;
3795 }
3796
3797
3798 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3799 PyObject *pyobj = 0;
3800
3801 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3802 return pyobj;
3803 }
3804
3805
3806 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3807 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3808 return 1;
3809 }
3810
3811
3812 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3813 PyObject *pyobj = 0;
3814
3815 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3816 return pyobj;
3817 }
3818
3819
3820 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3821 PyObject *resultobj = 0;
3822 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3823 PyObject *arg2 = (PyObject *) 0 ;
3824 void *argp1 = 0 ;
3825 int res1 = 0 ;
3826 PyObject * obj0 = 0 ;
3827 PyObject * obj1 = 0 ;
3828 char * kwnames[] = {
3829 (char *) "self",(char *) "_self", NULL
3830 };
3831
3832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3834 if (!SWIG_IsOK(res1)) {
3835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3836 }
3837 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3838 arg2 = obj1;
3839 {
3840 PyThreadState* __tstate = wxPyBeginAllowThreads();
3841 wxGridCellWorker__setOORInfo(arg1,arg2);
3842 wxPyEndAllowThreads(__tstate);
3843 if (PyErr_Occurred()) SWIG_fail;
3844 }
3845 resultobj = SWIG_Py_Void();
3846 return resultobj;
3847 fail:
3848 return NULL;
3849 }
3850
3851
3852 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3853 PyObject *resultobj = 0;
3854 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3855 void *argp1 = 0 ;
3856 int res1 = 0 ;
3857 PyObject *swig_obj[1] ;
3858
3859 if (!args) SWIG_fail;
3860 swig_obj[0] = args;
3861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3862 if (!SWIG_IsOK(res1)) {
3863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3864 }
3865 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3866 {
3867 PyThreadState* __tstate = wxPyBeginAllowThreads();
3868 delete_wxGridCellWorker(arg1);
3869
3870 wxPyEndAllowThreads(__tstate);
3871 if (PyErr_Occurred()) SWIG_fail;
3872 }
3873 resultobj = SWIG_Py_Void();
3874 return resultobj;
3875 fail:
3876 return NULL;
3877 }
3878
3879
3880 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3881 PyObject *resultobj = 0;
3882 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3883 wxString *arg2 = 0 ;
3884 void *argp1 = 0 ;
3885 int res1 = 0 ;
3886 bool temp2 = false ;
3887 PyObject * obj0 = 0 ;
3888 PyObject * obj1 = 0 ;
3889 char * kwnames[] = {
3890 (char *) "self",(char *) "params", NULL
3891 };
3892
3893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3895 if (!SWIG_IsOK(res1)) {
3896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3897 }
3898 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3899 {
3900 arg2 = wxString_in_helper(obj1);
3901 if (arg2 == NULL) SWIG_fail;
3902 temp2 = true;
3903 }
3904 {
3905 PyThreadState* __tstate = wxPyBeginAllowThreads();
3906 (arg1)->SetParameters((wxString const &)*arg2);
3907 wxPyEndAllowThreads(__tstate);
3908 if (PyErr_Occurred()) SWIG_fail;
3909 }
3910 resultobj = SWIG_Py_Void();
3911 {
3912 if (temp2)
3913 delete arg2;
3914 }
3915 return resultobj;
3916 fail:
3917 {
3918 if (temp2)
3919 delete arg2;
3920 }
3921 return NULL;
3922 }
3923
3924
3925 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3926 PyObject *resultobj = 0;
3927 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3928 void *argp1 = 0 ;
3929 int res1 = 0 ;
3930 PyObject *swig_obj[1] ;
3931
3932 if (!args) SWIG_fail;
3933 swig_obj[0] = args;
3934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3935 if (!SWIG_IsOK(res1)) {
3936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3937 }
3938 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3939 {
3940 PyThreadState* __tstate = wxPyBeginAllowThreads();
3941 (arg1)->IncRef();
3942 wxPyEndAllowThreads(__tstate);
3943 if (PyErr_Occurred()) SWIG_fail;
3944 }
3945 resultobj = SWIG_Py_Void();
3946 return resultobj;
3947 fail:
3948 return NULL;
3949 }
3950
3951
3952 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3953 PyObject *resultobj = 0;
3954 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3955 void *argp1 = 0 ;
3956 int res1 = 0 ;
3957 PyObject *swig_obj[1] ;
3958
3959 if (!args) SWIG_fail;
3960 swig_obj[0] = args;
3961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3962 if (!SWIG_IsOK(res1)) {
3963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3964 }
3965 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3966 {
3967 PyThreadState* __tstate = wxPyBeginAllowThreads();
3968 (arg1)->DecRef();
3969 wxPyEndAllowThreads(__tstate);
3970 if (PyErr_Occurred()) SWIG_fail;
3971 }
3972 resultobj = SWIG_Py_Void();
3973 return resultobj;
3974 fail:
3975 return NULL;
3976 }
3977
3978
3979 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3980 PyObject *obj;
3981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3982 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3983 return SWIG_Py_Void();
3984 }
3985
3986 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3987 PyObject *resultobj = 0;
3988 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3989 wxGrid *arg2 = 0 ;
3990 wxGridCellAttr *arg3 = 0 ;
3991 wxDC *arg4 = 0 ;
3992 wxRect *arg5 = 0 ;
3993 int arg6 ;
3994 int arg7 ;
3995 bool arg8 ;
3996 void *argp1 = 0 ;
3997 int res1 = 0 ;
3998 void *argp2 = 0 ;
3999 int res2 = 0 ;
4000 void *argp3 = 0 ;
4001 int res3 = 0 ;
4002 void *argp4 = 0 ;
4003 int res4 = 0 ;
4004 wxRect temp5 ;
4005 int val6 ;
4006 int ecode6 = 0 ;
4007 int val7 ;
4008 int ecode7 = 0 ;
4009 bool val8 ;
4010 int ecode8 = 0 ;
4011 PyObject * obj0 = 0 ;
4012 PyObject * obj1 = 0 ;
4013 PyObject * obj2 = 0 ;
4014 PyObject * obj3 = 0 ;
4015 PyObject * obj4 = 0 ;
4016 PyObject * obj5 = 0 ;
4017 PyObject * obj6 = 0 ;
4018 PyObject * obj7 = 0 ;
4019 char * kwnames[] = {
4020 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
4021 };
4022
4023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4025 if (!SWIG_IsOK(res1)) {
4026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4027 }
4028 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4029 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4030 if (!SWIG_IsOK(res2)) {
4031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4032 }
4033 if (!argp2) {
4034 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4035 }
4036 arg2 = reinterpret_cast< wxGrid * >(argp2);
4037 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4038 if (!SWIG_IsOK(res3)) {
4039 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4040 }
4041 if (!argp3) {
4042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4043 }
4044 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4045 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4046 if (!SWIG_IsOK(res4)) {
4047 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4048 }
4049 if (!argp4) {
4050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4051 }
4052 arg4 = reinterpret_cast< wxDC * >(argp4);
4053 {
4054 arg5 = &temp5;
4055 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
4056 }
4057 ecode6 = SWIG_AsVal_int(obj5, &val6);
4058 if (!SWIG_IsOK(ecode6)) {
4059 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
4060 }
4061 arg6 = static_cast< int >(val6);
4062 ecode7 = SWIG_AsVal_int(obj6, &val7);
4063 if (!SWIG_IsOK(ecode7)) {
4064 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
4065 }
4066 arg7 = static_cast< int >(val7);
4067 ecode8 = SWIG_AsVal_bool(obj7, &val8);
4068 if (!SWIG_IsOK(ecode8)) {
4069 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4070 }
4071 arg8 = static_cast< bool >(val8);
4072 {
4073 PyThreadState* __tstate = wxPyBeginAllowThreads();
4074 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4075 wxPyEndAllowThreads(__tstate);
4076 if (PyErr_Occurred()) SWIG_fail;
4077 }
4078 resultobj = SWIG_Py_Void();
4079 return resultobj;
4080 fail:
4081 return NULL;
4082 }
4083
4084
4085 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4086 PyObject *resultobj = 0;
4087 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4088 wxGrid *arg2 = 0 ;
4089 wxGridCellAttr *arg3 = 0 ;
4090 wxDC *arg4 = 0 ;
4091 int arg5 ;
4092 int arg6 ;
4093 wxSize result;
4094 void *argp1 = 0 ;
4095 int res1 = 0 ;
4096 void *argp2 = 0 ;
4097 int res2 = 0 ;
4098 void *argp3 = 0 ;
4099 int res3 = 0 ;
4100 void *argp4 = 0 ;
4101 int res4 = 0 ;
4102 int val5 ;
4103 int ecode5 = 0 ;
4104 int val6 ;
4105 int ecode6 = 0 ;
4106 PyObject * obj0 = 0 ;
4107 PyObject * obj1 = 0 ;
4108 PyObject * obj2 = 0 ;
4109 PyObject * obj3 = 0 ;
4110 PyObject * obj4 = 0 ;
4111 PyObject * obj5 = 0 ;
4112 char * kwnames[] = {
4113 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4114 };
4115
4116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4118 if (!SWIG_IsOK(res1)) {
4119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4120 }
4121 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4122 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4123 if (!SWIG_IsOK(res2)) {
4124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4125 }
4126 if (!argp2) {
4127 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4128 }
4129 arg2 = reinterpret_cast< wxGrid * >(argp2);
4130 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4131 if (!SWIG_IsOK(res3)) {
4132 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4133 }
4134 if (!argp3) {
4135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4136 }
4137 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4138 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4139 if (!SWIG_IsOK(res4)) {
4140 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4141 }
4142 if (!argp4) {
4143 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4144 }
4145 arg4 = reinterpret_cast< wxDC * >(argp4);
4146 ecode5 = SWIG_AsVal_int(obj4, &val5);
4147 if (!SWIG_IsOK(ecode5)) {
4148 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4149 }
4150 arg5 = static_cast< int >(val5);
4151 ecode6 = SWIG_AsVal_int(obj5, &val6);
4152 if (!SWIG_IsOK(ecode6)) {
4153 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4154 }
4155 arg6 = static_cast< int >(val6);
4156 {
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4159 wxPyEndAllowThreads(__tstate);
4160 if (PyErr_Occurred()) SWIG_fail;
4161 }
4162 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4163 return resultobj;
4164 fail:
4165 return NULL;
4166 }
4167
4168
4169 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4170 PyObject *resultobj = 0;
4171 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4172 wxGridCellRenderer *result = 0 ;
4173 void *argp1 = 0 ;
4174 int res1 = 0 ;
4175 PyObject *swig_obj[1] ;
4176
4177 if (!args) SWIG_fail;
4178 swig_obj[0] = args;
4179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4180 if (!SWIG_IsOK(res1)) {
4181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4182 }
4183 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4184 {
4185 PyThreadState* __tstate = wxPyBeginAllowThreads();
4186 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4187 wxPyEndAllowThreads(__tstate);
4188 if (PyErr_Occurred()) SWIG_fail;
4189 }
4190 {
4191 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4192 }
4193 return resultobj;
4194 fail:
4195 return NULL;
4196 }
4197
4198
4199 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4200 PyObject *obj;
4201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4202 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4203 return SWIG_Py_Void();
4204 }
4205
4206 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4207 PyObject *resultobj = 0;
4208 wxPyGridCellRenderer *result = 0 ;
4209
4210 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4211 {
4212 PyThreadState* __tstate = wxPyBeginAllowThreads();
4213 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4214 wxPyEndAllowThreads(__tstate);
4215 if (PyErr_Occurred()) SWIG_fail;
4216 }
4217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4225 PyObject *resultobj = 0;
4226 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4227 PyObject *arg2 = (PyObject *) 0 ;
4228 PyObject *arg3 = (PyObject *) 0 ;
4229 void *argp1 = 0 ;
4230 int res1 = 0 ;
4231 PyObject * obj0 = 0 ;
4232 PyObject * obj1 = 0 ;
4233 PyObject * obj2 = 0 ;
4234 char * kwnames[] = {
4235 (char *) "self",(char *) "self",(char *) "_class", NULL
4236 };
4237
4238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4240 if (!SWIG_IsOK(res1)) {
4241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4242 }
4243 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4244 arg2 = obj1;
4245 arg3 = obj2;
4246 {
4247 PyThreadState* __tstate = wxPyBeginAllowThreads();
4248 (arg1)->_setCallbackInfo(arg2,arg3);
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_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4260 PyObject *resultobj = 0;
4261 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4262 wxString *arg2 = 0 ;
4263 void *argp1 = 0 ;
4264 int res1 = 0 ;
4265 bool temp2 = false ;
4266 PyObject * obj0 = 0 ;
4267 PyObject * obj1 = 0 ;
4268 char * kwnames[] = {
4269 (char *) "self",(char *) "params", NULL
4270 };
4271
4272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4274 if (!SWIG_IsOK(res1)) {
4275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4276 }
4277 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4278 {
4279 arg2 = wxString_in_helper(obj1);
4280 if (arg2 == NULL) SWIG_fail;
4281 temp2 = true;
4282 }
4283 {
4284 PyThreadState* __tstate = wxPyBeginAllowThreads();
4285 (arg1)->SetParameters((wxString const &)*arg2);
4286 wxPyEndAllowThreads(__tstate);
4287 if (PyErr_Occurred()) SWIG_fail;
4288 }
4289 resultobj = SWIG_Py_Void();
4290 {
4291 if (temp2)
4292 delete arg2;
4293 }
4294 return resultobj;
4295 fail:
4296 {
4297 if (temp2)
4298 delete arg2;
4299 }
4300 return NULL;
4301 }
4302
4303
4304 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4305 PyObject *obj;
4306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4307 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4308 return SWIG_Py_Void();
4309 }
4310
4311 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4312 return SWIG_Python_InitShadowInstance(args);
4313 }
4314
4315 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4316 PyObject *resultobj = 0;
4317 wxGridCellStringRenderer *result = 0 ;
4318
4319 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4323 wxPyEndAllowThreads(__tstate);
4324 if (PyErr_Occurred()) SWIG_fail;
4325 }
4326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4327 return resultobj;
4328 fail:
4329 return NULL;
4330 }
4331
4332
4333 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4334 PyObject *obj;
4335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4336 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4337 return SWIG_Py_Void();
4338 }
4339
4340 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4341 return SWIG_Python_InitShadowInstance(args);
4342 }
4343
4344 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4345 PyObject *resultobj = 0;
4346 wxGridCellNumberRenderer *result = 0 ;
4347
4348 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4349 {
4350 PyThreadState* __tstate = wxPyBeginAllowThreads();
4351 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4352 wxPyEndAllowThreads(__tstate);
4353 if (PyErr_Occurred()) SWIG_fail;
4354 }
4355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4356 return resultobj;
4357 fail:
4358 return NULL;
4359 }
4360
4361
4362 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4363 PyObject *obj;
4364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4365 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4366 return SWIG_Py_Void();
4367 }
4368
4369 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4370 return SWIG_Python_InitShadowInstance(args);
4371 }
4372
4373 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4374 PyObject *resultobj = 0;
4375 int arg1 = (int) -1 ;
4376 int arg2 = (int) -1 ;
4377 wxGridCellFloatRenderer *result = 0 ;
4378 int val1 ;
4379 int ecode1 = 0 ;
4380 int val2 ;
4381 int ecode2 = 0 ;
4382 PyObject * obj0 = 0 ;
4383 PyObject * obj1 = 0 ;
4384 char * kwnames[] = {
4385 (char *) "width",(char *) "precision", NULL
4386 };
4387
4388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4389 if (obj0) {
4390 ecode1 = SWIG_AsVal_int(obj0, &val1);
4391 if (!SWIG_IsOK(ecode1)) {
4392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4393 }
4394 arg1 = static_cast< int >(val1);
4395 }
4396 if (obj1) {
4397 ecode2 = SWIG_AsVal_int(obj1, &val2);
4398 if (!SWIG_IsOK(ecode2)) {
4399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4400 }
4401 arg2 = static_cast< int >(val2);
4402 }
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4406 wxPyEndAllowThreads(__tstate);
4407 if (PyErr_Occurred()) SWIG_fail;
4408 }
4409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4410 return resultobj;
4411 fail:
4412 return NULL;
4413 }
4414
4415
4416 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4417 PyObject *resultobj = 0;
4418 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4419 int result;
4420 void *argp1 = 0 ;
4421 int res1 = 0 ;
4422 PyObject *swig_obj[1] ;
4423
4424 if (!args) SWIG_fail;
4425 swig_obj[0] = args;
4426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4427 if (!SWIG_IsOK(res1)) {
4428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4429 }
4430 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 resultobj = SWIG_From_int(static_cast< int >(result));
4438 return resultobj;
4439 fail:
4440 return NULL;
4441 }
4442
4443
4444 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4445 PyObject *resultobj = 0;
4446 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4447 int arg2 ;
4448 void *argp1 = 0 ;
4449 int res1 = 0 ;
4450 int val2 ;
4451 int ecode2 = 0 ;
4452 PyObject * obj0 = 0 ;
4453 PyObject * obj1 = 0 ;
4454 char * kwnames[] = {
4455 (char *) "self",(char *) "width", NULL
4456 };
4457
4458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4460 if (!SWIG_IsOK(res1)) {
4461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4462 }
4463 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4464 ecode2 = SWIG_AsVal_int(obj1, &val2);
4465 if (!SWIG_IsOK(ecode2)) {
4466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4467 }
4468 arg2 = static_cast< int >(val2);
4469 {
4470 PyThreadState* __tstate = wxPyBeginAllowThreads();
4471 (arg1)->SetWidth(arg2);
4472 wxPyEndAllowThreads(__tstate);
4473 if (PyErr_Occurred()) SWIG_fail;
4474 }
4475 resultobj = SWIG_Py_Void();
4476 return resultobj;
4477 fail:
4478 return NULL;
4479 }
4480
4481
4482 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4483 PyObject *resultobj = 0;
4484 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4485 int result;
4486 void *argp1 = 0 ;
4487 int res1 = 0 ;
4488 PyObject *swig_obj[1] ;
4489
4490 if (!args) SWIG_fail;
4491 swig_obj[0] = args;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4495 }
4496 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4497 {
4498 PyThreadState* __tstate = wxPyBeginAllowThreads();
4499 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4500 wxPyEndAllowThreads(__tstate);
4501 if (PyErr_Occurred()) SWIG_fail;
4502 }
4503 resultobj = SWIG_From_int(static_cast< int >(result));
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4511 PyObject *resultobj = 0;
4512 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4513 int arg2 ;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 int val2 ;
4517 int ecode2 = 0 ;
4518 PyObject * obj0 = 0 ;
4519 PyObject * obj1 = 0 ;
4520 char * kwnames[] = {
4521 (char *) "self",(char *) "precision", NULL
4522 };
4523
4524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4528 }
4529 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4530 ecode2 = SWIG_AsVal_int(obj1, &val2);
4531 if (!SWIG_IsOK(ecode2)) {
4532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4533 }
4534 arg2 = static_cast< int >(val2);
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 (arg1)->SetPrecision(arg2);
4538 wxPyEndAllowThreads(__tstate);
4539 if (PyErr_Occurred()) SWIG_fail;
4540 }
4541 resultobj = SWIG_Py_Void();
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549 PyObject *obj;
4550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4551 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4552 return SWIG_Py_Void();
4553 }
4554
4555 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4556 return SWIG_Python_InitShadowInstance(args);
4557 }
4558
4559 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4560 PyObject *resultobj = 0;
4561 wxGridCellBoolRenderer *result = 0 ;
4562
4563 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4564 {
4565 PyThreadState* __tstate = wxPyBeginAllowThreads();
4566 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4567 wxPyEndAllowThreads(__tstate);
4568 if (PyErr_Occurred()) SWIG_fail;
4569 }
4570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4571 return resultobj;
4572 fail:
4573 return NULL;
4574 }
4575
4576
4577 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4578 PyObject *obj;
4579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4580 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4581 return SWIG_Py_Void();
4582 }
4583
4584 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4585 return SWIG_Python_InitShadowInstance(args);
4586 }
4587
4588 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj = 0;
4590 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4591 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4592 wxGridCellDateTimeRenderer *result = 0 ;
4593 PyObject * obj0 = 0 ;
4594 PyObject * obj1 = 0 ;
4595 char * kwnames[] = {
4596 (char *) "outformat",(char *) "informat", NULL
4597 };
4598
4599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4600 if (obj0) {
4601 {
4602 wxString* sptr = wxString_in_helper(obj0);
4603 if (sptr == NULL) SWIG_fail;
4604 arg1 = *sptr;
4605 delete sptr;
4606 }
4607 }
4608 if (obj1) {
4609 {
4610 wxString* sptr = wxString_in_helper(obj1);
4611 if (sptr == NULL) SWIG_fail;
4612 arg2 = *sptr;
4613 delete sptr;
4614 }
4615 }
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4619 wxPyEndAllowThreads(__tstate);
4620 if (PyErr_Occurred()) SWIG_fail;
4621 }
4622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4623 return resultobj;
4624 fail:
4625 return NULL;
4626 }
4627
4628
4629 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630 PyObject *obj;
4631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4632 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4633 return SWIG_Py_Void();
4634 }
4635
4636 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4637 return SWIG_Python_InitShadowInstance(args);
4638 }
4639
4640 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4641 PyObject *resultobj = 0;
4642 wxString const &arg1_defvalue = wxPyEmptyString ;
4643 wxString *arg1 = (wxString *) &arg1_defvalue ;
4644 wxGridCellEnumRenderer *result = 0 ;
4645 bool temp1 = false ;
4646 PyObject * obj0 = 0 ;
4647 char * kwnames[] = {
4648 (char *) "choices", NULL
4649 };
4650
4651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4652 if (obj0) {
4653 {
4654 arg1 = wxString_in_helper(obj0);
4655 if (arg1 == NULL) SWIG_fail;
4656 temp1 = true;
4657 }
4658 }
4659 {
4660 PyThreadState* __tstate = wxPyBeginAllowThreads();
4661 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4662 wxPyEndAllowThreads(__tstate);
4663 if (PyErr_Occurred()) SWIG_fail;
4664 }
4665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4666 {
4667 if (temp1)
4668 delete arg1;
4669 }
4670 return resultobj;
4671 fail:
4672 {
4673 if (temp1)
4674 delete arg1;
4675 }
4676 return NULL;
4677 }
4678
4679
4680 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4681 PyObject *obj;
4682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4683 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4684 return SWIG_Py_Void();
4685 }
4686
4687 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4688 return SWIG_Python_InitShadowInstance(args);
4689 }
4690
4691 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4692 PyObject *resultobj = 0;
4693 wxGridCellAutoWrapStringRenderer *result = 0 ;
4694
4695 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4696 {
4697 PyThreadState* __tstate = wxPyBeginAllowThreads();
4698 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4710 PyObject *obj;
4711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4712 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4713 return SWIG_Py_Void();
4714 }
4715
4716 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4717 return SWIG_Python_InitShadowInstance(args);
4718 }
4719
4720 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4721 PyObject *resultobj = 0;
4722 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4723 bool result;
4724 void *argp1 = 0 ;
4725 int res1 = 0 ;
4726 PyObject *swig_obj[1] ;
4727
4728 if (!args) SWIG_fail;
4729 swig_obj[0] = args;
4730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4731 if (!SWIG_IsOK(res1)) {
4732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4733 }
4734 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4735 {
4736 PyThreadState* __tstate = wxPyBeginAllowThreads();
4737 result = (bool)(arg1)->IsCreated();
4738 wxPyEndAllowThreads(__tstate);
4739 if (PyErr_Occurred()) SWIG_fail;
4740 }
4741 {
4742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4743 }
4744 return resultobj;
4745 fail:
4746 return NULL;
4747 }
4748
4749
4750 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4751 PyObject *resultobj = 0;
4752 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4753 wxControl *result = 0 ;
4754 void *argp1 = 0 ;
4755 int res1 = 0 ;
4756 PyObject *swig_obj[1] ;
4757
4758 if (!args) SWIG_fail;
4759 swig_obj[0] = args;
4760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4761 if (!SWIG_IsOK(res1)) {
4762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4763 }
4764 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (wxControl *)(arg1)->GetControl();
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 {
4772 resultobj = wxPyMake_wxObject(result, 0);
4773 }
4774 return resultobj;
4775 fail:
4776 return NULL;
4777 }
4778
4779
4780 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4781 PyObject *resultobj = 0;
4782 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4783 wxControl *arg2 = (wxControl *) 0 ;
4784 void *argp1 = 0 ;
4785 int res1 = 0 ;
4786 void *argp2 = 0 ;
4787 int res2 = 0 ;
4788 PyObject * obj0 = 0 ;
4789 PyObject * obj1 = 0 ;
4790 char * kwnames[] = {
4791 (char *) "self",(char *) "control", NULL
4792 };
4793
4794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4796 if (!SWIG_IsOK(res1)) {
4797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4798 }
4799 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4801 if (!SWIG_IsOK(res2)) {
4802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4803 }
4804 arg2 = reinterpret_cast< wxControl * >(argp2);
4805 {
4806 PyThreadState* __tstate = wxPyBeginAllowThreads();
4807 (arg1)->SetControl(arg2);
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_Py_Void();
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4819 PyObject *resultobj = 0;
4820 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4821 wxGridCellAttr *result = 0 ;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 PyObject *swig_obj[1] ;
4825
4826 if (!args) SWIG_fail;
4827 swig_obj[0] = args;
4828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4831 }
4832 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 {
4840 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4841 }
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4851 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4852 void *argp1 = 0 ;
4853 int res1 = 0 ;
4854 void *argp2 = 0 ;
4855 int res2 = 0 ;
4856 PyObject * obj0 = 0 ;
4857 PyObject * obj1 = 0 ;
4858 char * kwnames[] = {
4859 (char *) "self",(char *) "attr", NULL
4860 };
4861
4862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4864 if (!SWIG_IsOK(res1)) {
4865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4866 }
4867 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4868 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4869 if (!SWIG_IsOK(res2)) {
4870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4871 }
4872 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4873 {
4874 PyThreadState* __tstate = wxPyBeginAllowThreads();
4875 (arg1)->SetCellAttr(arg2);
4876 wxPyEndAllowThreads(__tstate);
4877 if (PyErr_Occurred()) SWIG_fail;
4878 }
4879 resultobj = SWIG_Py_Void();
4880 return resultobj;
4881 fail:
4882 return NULL;
4883 }
4884
4885
4886 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4887 PyObject *resultobj = 0;
4888 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4889 wxWindow *arg2 = (wxWindow *) 0 ;
4890 int arg3 ;
4891 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4892 void *argp1 = 0 ;
4893 int res1 = 0 ;
4894 void *argp2 = 0 ;
4895 int res2 = 0 ;
4896 int val3 ;
4897 int ecode3 = 0 ;
4898 void *argp4 = 0 ;
4899 int res4 = 0 ;
4900 PyObject * obj0 = 0 ;
4901 PyObject * obj1 = 0 ;
4902 PyObject * obj2 = 0 ;
4903 PyObject * obj3 = 0 ;
4904 char * kwnames[] = {
4905 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4906 };
4907
4908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4910 if (!SWIG_IsOK(res1)) {
4911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4912 }
4913 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4914 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4915 if (!SWIG_IsOK(res2)) {
4916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4917 }
4918 arg2 = reinterpret_cast< wxWindow * >(argp2);
4919 ecode3 = SWIG_AsVal_int(obj2, &val3);
4920 if (!SWIG_IsOK(ecode3)) {
4921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4922 }
4923 arg3 = static_cast< int >(val3);
4924 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4925 if (!SWIG_IsOK(res4)) {
4926 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4927 }
4928 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4929 {
4930 PyThreadState* __tstate = wxPyBeginAllowThreads();
4931 (arg1)->Create(arg2,arg3,arg4);
4932 wxPyEndAllowThreads(__tstate);
4933 if (PyErr_Occurred()) SWIG_fail;
4934 }
4935 resultobj = SWIG_Py_Void();
4936 return resultobj;
4937 fail:
4938 return NULL;
4939 }
4940
4941
4942 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4943 PyObject *resultobj = 0;
4944 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4945 int arg2 ;
4946 int arg3 ;
4947 wxGrid *arg4 = (wxGrid *) 0 ;
4948 void *argp1 = 0 ;
4949 int res1 = 0 ;
4950 int val2 ;
4951 int ecode2 = 0 ;
4952 int val3 ;
4953 int ecode3 = 0 ;
4954 void *argp4 = 0 ;
4955 int res4 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 PyObject * obj2 = 0 ;
4959 PyObject * obj3 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4966 if (!SWIG_IsOK(res1)) {
4967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4968 }
4969 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4970 ecode2 = SWIG_AsVal_int(obj1, &val2);
4971 if (!SWIG_IsOK(ecode2)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4973 }
4974 arg2 = static_cast< int >(val2);
4975 ecode3 = SWIG_AsVal_int(obj2, &val3);
4976 if (!SWIG_IsOK(ecode3)) {
4977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4978 }
4979 arg3 = static_cast< int >(val3);
4980 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4981 if (!SWIG_IsOK(res4)) {
4982 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4983 }
4984 arg4 = reinterpret_cast< wxGrid * >(argp4);
4985 {
4986 PyThreadState* __tstate = wxPyBeginAllowThreads();
4987 (arg1)->BeginEdit(arg2,arg3,arg4);
4988 wxPyEndAllowThreads(__tstate);
4989 if (PyErr_Occurred()) SWIG_fail;
4990 }
4991 resultobj = SWIG_Py_Void();
4992 return resultobj;
4993 fail:
4994 return NULL;
4995 }
4996
4997
4998 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4999 PyObject *resultobj = 0;
5000 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5001 int arg2 ;
5002 int arg3 ;
5003 wxGrid *arg4 = (wxGrid *) 0 ;
5004 bool result;
5005 void *argp1 = 0 ;
5006 int res1 = 0 ;
5007 int val2 ;
5008 int ecode2 = 0 ;
5009 int val3 ;
5010 int ecode3 = 0 ;
5011 void *argp4 = 0 ;
5012 int res4 = 0 ;
5013 PyObject * obj0 = 0 ;
5014 PyObject * obj1 = 0 ;
5015 PyObject * obj2 = 0 ;
5016 PyObject * obj3 = 0 ;
5017 char * kwnames[] = {
5018 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5019 };
5020
5021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5023 if (!SWIG_IsOK(res1)) {
5024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5025 }
5026 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5027 ecode2 = SWIG_AsVal_int(obj1, &val2);
5028 if (!SWIG_IsOK(ecode2)) {
5029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5030 }
5031 arg2 = static_cast< int >(val2);
5032 ecode3 = SWIG_AsVal_int(obj2, &val3);
5033 if (!SWIG_IsOK(ecode3)) {
5034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5035 }
5036 arg3 = static_cast< int >(val3);
5037 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5038 if (!SWIG_IsOK(res4)) {
5039 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5040 }
5041 arg4 = reinterpret_cast< wxGrid * >(argp4);
5042 {
5043 PyThreadState* __tstate = wxPyBeginAllowThreads();
5044 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 {
5049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5050 }
5051 return resultobj;
5052 fail:
5053 return NULL;
5054 }
5055
5056
5057 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5058 PyObject *resultobj = 0;
5059 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5060 void *argp1 = 0 ;
5061 int res1 = 0 ;
5062 PyObject *swig_obj[1] ;
5063
5064 if (!args) SWIG_fail;
5065 swig_obj[0] = args;
5066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5067 if (!SWIG_IsOK(res1)) {
5068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5069 }
5070 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 (arg1)->Reset();
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 resultobj = SWIG_Py_Void();
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5085 PyObject *resultobj = 0;
5086 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5087 wxGridCellEditor *result = 0 ;
5088 void *argp1 = 0 ;
5089 int res1 = 0 ;
5090 PyObject *swig_obj[1] ;
5091
5092 if (!args) SWIG_fail;
5093 swig_obj[0] = args;
5094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5095 if (!SWIG_IsOK(res1)) {
5096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5097 }
5098 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5099 {
5100 PyThreadState* __tstate = wxPyBeginAllowThreads();
5101 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5102 wxPyEndAllowThreads(__tstate);
5103 if (PyErr_Occurred()) SWIG_fail;
5104 }
5105 {
5106 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5107 }
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj = 0;
5116 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5117 wxRect *arg2 = 0 ;
5118 void *argp1 = 0 ;
5119 int res1 = 0 ;
5120 wxRect temp2 ;
5121 PyObject * obj0 = 0 ;
5122 PyObject * obj1 = 0 ;
5123 char * kwnames[] = {
5124 (char *) "self",(char *) "rect", NULL
5125 };
5126
5127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5129 if (!SWIG_IsOK(res1)) {
5130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5131 }
5132 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5133 {
5134 arg2 = &temp2;
5135 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5136 }
5137 {
5138 PyThreadState* __tstate = wxPyBeginAllowThreads();
5139 (arg1)->SetSize((wxRect const &)*arg2);
5140 wxPyEndAllowThreads(__tstate);
5141 if (PyErr_Occurred()) SWIG_fail;
5142 }
5143 resultobj = SWIG_Py_Void();
5144 return resultobj;
5145 fail:
5146 return NULL;
5147 }
5148
5149
5150 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5151 PyObject *resultobj = 0;
5152 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5153 bool arg2 ;
5154 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5155 void *argp1 = 0 ;
5156 int res1 = 0 ;
5157 bool val2 ;
5158 int ecode2 = 0 ;
5159 void *argp3 = 0 ;
5160 int res3 = 0 ;
5161 PyObject * obj0 = 0 ;
5162 PyObject * obj1 = 0 ;
5163 PyObject * obj2 = 0 ;
5164 char * kwnames[] = {
5165 (char *) "self",(char *) "show",(char *) "attr", NULL
5166 };
5167
5168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5170 if (!SWIG_IsOK(res1)) {
5171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5172 }
5173 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5174 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5175 if (!SWIG_IsOK(ecode2)) {
5176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5177 }
5178 arg2 = static_cast< bool >(val2);
5179 if (obj2) {
5180 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5181 if (!SWIG_IsOK(res3)) {
5182 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5183 }
5184 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5185 }
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 (arg1)->Show(arg2,arg3);
5189 wxPyEndAllowThreads(__tstate);
5190 if (PyErr_Occurred()) SWIG_fail;
5191 }
5192 resultobj = SWIG_Py_Void();
5193 return resultobj;
5194 fail:
5195 return NULL;
5196 }
5197
5198
5199 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5200 PyObject *resultobj = 0;
5201 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5202 wxRect *arg2 = 0 ;
5203 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5204 void *argp1 = 0 ;
5205 int res1 = 0 ;
5206 wxRect temp2 ;
5207 void *argp3 = 0 ;
5208 int res3 = 0 ;
5209 PyObject * obj0 = 0 ;
5210 PyObject * obj1 = 0 ;
5211 PyObject * obj2 = 0 ;
5212 char * kwnames[] = {
5213 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5214 };
5215
5216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5218 if (!SWIG_IsOK(res1)) {
5219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5220 }
5221 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5222 {
5223 arg2 = &temp2;
5224 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5225 }
5226 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5227 if (!SWIG_IsOK(res3)) {
5228 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5229 }
5230 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5231 {
5232 PyThreadState* __tstate = wxPyBeginAllowThreads();
5233 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5234 wxPyEndAllowThreads(__tstate);
5235 if (PyErr_Occurred()) SWIG_fail;
5236 }
5237 resultobj = SWIG_Py_Void();
5238 return resultobj;
5239 fail:
5240 return NULL;
5241 }
5242
5243
5244 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5245 PyObject *resultobj = 0;
5246 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5247 wxKeyEvent *arg2 = 0 ;
5248 bool result;
5249 void *argp1 = 0 ;
5250 int res1 = 0 ;
5251 void *argp2 = 0 ;
5252 int res2 = 0 ;
5253 PyObject * obj0 = 0 ;
5254 PyObject * obj1 = 0 ;
5255 char * kwnames[] = {
5256 (char *) "self",(char *) "event", NULL
5257 };
5258
5259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5261 if (!SWIG_IsOK(res1)) {
5262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5263 }
5264 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5265 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5266 if (!SWIG_IsOK(res2)) {
5267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5268 }
5269 if (!argp2) {
5270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5271 }
5272 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5273 {
5274 PyThreadState* __tstate = wxPyBeginAllowThreads();
5275 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5276 wxPyEndAllowThreads(__tstate);
5277 if (PyErr_Occurred()) SWIG_fail;
5278 }
5279 {
5280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5281 }
5282 return resultobj;
5283 fail:
5284 return NULL;
5285 }
5286
5287
5288 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5289 PyObject *resultobj = 0;
5290 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5291 wxKeyEvent *arg2 = 0 ;
5292 void *argp1 = 0 ;
5293 int res1 = 0 ;
5294 void *argp2 = 0 ;
5295 int res2 = 0 ;
5296 PyObject * obj0 = 0 ;
5297 PyObject * obj1 = 0 ;
5298 char * kwnames[] = {
5299 (char *) "self",(char *) "event", NULL
5300 };
5301
5302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5304 if (!SWIG_IsOK(res1)) {
5305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5306 }
5307 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5309 if (!SWIG_IsOK(res2)) {
5310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5311 }
5312 if (!argp2) {
5313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5314 }
5315 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 (arg1)->StartingKey(*arg2);
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 resultobj = SWIG_Py_Void();
5323 return resultobj;
5324 fail:
5325 return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330 PyObject *resultobj = 0;
5331 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5332 void *argp1 = 0 ;
5333 int res1 = 0 ;
5334 PyObject *swig_obj[1] ;
5335
5336 if (!args) SWIG_fail;
5337 swig_obj[0] = args;
5338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5339 if (!SWIG_IsOK(res1)) {
5340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5341 }
5342 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5343 {
5344 PyThreadState* __tstate = wxPyBeginAllowThreads();
5345 (arg1)->StartingClick();
5346 wxPyEndAllowThreads(__tstate);
5347 if (PyErr_Occurred()) SWIG_fail;
5348 }
5349 resultobj = SWIG_Py_Void();
5350 return resultobj;
5351 fail:
5352 return NULL;
5353 }
5354
5355
5356 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5357 PyObject *resultobj = 0;
5358 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5359 wxKeyEvent *arg2 = 0 ;
5360 void *argp1 = 0 ;
5361 int res1 = 0 ;
5362 void *argp2 = 0 ;
5363 int res2 = 0 ;
5364 PyObject * obj0 = 0 ;
5365 PyObject * obj1 = 0 ;
5366 char * kwnames[] = {
5367 (char *) "self",(char *) "event", NULL
5368 };
5369
5370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5372 if (!SWIG_IsOK(res1)) {
5373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5374 }
5375 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5377 if (!SWIG_IsOK(res2)) {
5378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5379 }
5380 if (!argp2) {
5381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5382 }
5383 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5384 {
5385 PyThreadState* __tstate = wxPyBeginAllowThreads();
5386 (arg1)->HandleReturn(*arg2);
5387 wxPyEndAllowThreads(__tstate);
5388 if (PyErr_Occurred()) SWIG_fail;
5389 }
5390 resultobj = SWIG_Py_Void();
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5398 PyObject *resultobj = 0;
5399 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5400 void *argp1 = 0 ;
5401 int res1 = 0 ;
5402 PyObject *swig_obj[1] ;
5403
5404 if (!args) SWIG_fail;
5405 swig_obj[0] = args;
5406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5407 if (!SWIG_IsOK(res1)) {
5408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5409 }
5410 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5411 {
5412 PyThreadState* __tstate = wxPyBeginAllowThreads();
5413 (arg1)->Destroy();
5414 wxPyEndAllowThreads(__tstate);
5415 if (PyErr_Occurred()) SWIG_fail;
5416 }
5417 resultobj = SWIG_Py_Void();
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425 PyObject *obj;
5426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5427 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5428 return SWIG_Py_Void();
5429 }
5430
5431 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5432 PyObject *resultobj = 0;
5433 wxPyGridCellEditor *result = 0 ;
5434
5435 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5439 wxPyEndAllowThreads(__tstate);
5440 if (PyErr_Occurred()) SWIG_fail;
5441 }
5442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5443 return resultobj;
5444 fail:
5445 return NULL;
5446 }
5447
5448
5449 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5450 PyObject *resultobj = 0;
5451 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5452 PyObject *arg2 = (PyObject *) 0 ;
5453 PyObject *arg3 = (PyObject *) 0 ;
5454 void *argp1 = 0 ;
5455 int res1 = 0 ;
5456 PyObject * obj0 = 0 ;
5457 PyObject * obj1 = 0 ;
5458 PyObject * obj2 = 0 ;
5459 char * kwnames[] = {
5460 (char *) "self",(char *) "self",(char *) "_class", NULL
5461 };
5462
5463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5465 if (!SWIG_IsOK(res1)) {
5466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5467 }
5468 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5469 arg2 = obj1;
5470 arg3 = obj2;
5471 {
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 (arg1)->_setCallbackInfo(arg2,arg3);
5474 wxPyEndAllowThreads(__tstate);
5475 if (PyErr_Occurred()) SWIG_fail;
5476 }
5477 resultobj = SWIG_Py_Void();
5478 return resultobj;
5479 fail:
5480 return NULL;
5481 }
5482
5483
5484 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5485 PyObject *resultobj = 0;
5486 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5487 wxString *arg2 = 0 ;
5488 void *argp1 = 0 ;
5489 int res1 = 0 ;
5490 bool temp2 = false ;
5491 PyObject * obj0 = 0 ;
5492 PyObject * obj1 = 0 ;
5493 char * kwnames[] = {
5494 (char *) "self",(char *) "params", NULL
5495 };
5496
5497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5499 if (!SWIG_IsOK(res1)) {
5500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5501 }
5502 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5503 {
5504 arg2 = wxString_in_helper(obj1);
5505 if (arg2 == NULL) SWIG_fail;
5506 temp2 = true;
5507 }
5508 {
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 (arg1)->SetParameters((wxString const &)*arg2);
5511 wxPyEndAllowThreads(__tstate);
5512 if (PyErr_Occurred()) SWIG_fail;
5513 }
5514 resultobj = SWIG_Py_Void();
5515 {
5516 if (temp2)
5517 delete arg2;
5518 }
5519 return resultobj;
5520 fail:
5521 {
5522 if (temp2)
5523 delete arg2;
5524 }
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5530 PyObject *obj;
5531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5532 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5533 return SWIG_Py_Void();
5534 }
5535
5536 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5537 return SWIG_Python_InitShadowInstance(args);
5538 }
5539
5540 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5541 PyObject *resultobj = 0;
5542 wxGridCellTextEditor *result = 0 ;
5543
5544 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5545 {
5546 PyThreadState* __tstate = wxPyBeginAllowThreads();
5547 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5552 return resultobj;
5553 fail:
5554 return NULL;
5555 }
5556
5557
5558 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5559 PyObject *resultobj = 0;
5560 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5561 wxString result;
5562 void *argp1 = 0 ;
5563 int res1 = 0 ;
5564 PyObject *swig_obj[1] ;
5565
5566 if (!args) SWIG_fail;
5567 swig_obj[0] = args;
5568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5569 if (!SWIG_IsOK(res1)) {
5570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5571 }
5572 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5573 {
5574 PyThreadState* __tstate = wxPyBeginAllowThreads();
5575 result = (arg1)->GetValue();
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 #if wxUSE_UNICODE
5581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5582 #else
5583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5584 #endif
5585 }
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *obj;
5594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5595 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5596 return SWIG_Py_Void();
5597 }
5598
5599 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 return SWIG_Python_InitShadowInstance(args);
5601 }
5602
5603 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj = 0;
5605 int arg1 = (int) -1 ;
5606 int arg2 = (int) -1 ;
5607 wxGridCellNumberEditor *result = 0 ;
5608 int val1 ;
5609 int ecode1 = 0 ;
5610 int val2 ;
5611 int ecode2 = 0 ;
5612 PyObject * obj0 = 0 ;
5613 PyObject * obj1 = 0 ;
5614 char * kwnames[] = {
5615 (char *) "min",(char *) "max", NULL
5616 };
5617
5618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5619 if (obj0) {
5620 ecode1 = SWIG_AsVal_int(obj0, &val1);
5621 if (!SWIG_IsOK(ecode1)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5623 }
5624 arg1 = static_cast< int >(val1);
5625 }
5626 if (obj1) {
5627 ecode2 = SWIG_AsVal_int(obj1, &val2);
5628 if (!SWIG_IsOK(ecode2)) {
5629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5630 }
5631 arg2 = static_cast< int >(val2);
5632 }
5633 {
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5636 wxPyEndAllowThreads(__tstate);
5637 if (PyErr_Occurred()) SWIG_fail;
5638 }
5639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5647 PyObject *obj;
5648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5649 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5650 return SWIG_Py_Void();
5651 }
5652
5653 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5654 return SWIG_Python_InitShadowInstance(args);
5655 }
5656
5657 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj = 0;
5659 int arg1 = (int) -1 ;
5660 int arg2 = (int) -1 ;
5661 wxGridCellFloatEditor *result = 0 ;
5662 int val1 ;
5663 int ecode1 = 0 ;
5664 int val2 ;
5665 int ecode2 = 0 ;
5666 PyObject * obj0 = 0 ;
5667 PyObject * obj1 = 0 ;
5668 char * kwnames[] = {
5669 (char *) "width",(char *) "precision", NULL
5670 };
5671
5672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5673 if (obj0) {
5674 ecode1 = SWIG_AsVal_int(obj0, &val1);
5675 if (!SWIG_IsOK(ecode1)) {
5676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5677 }
5678 arg1 = static_cast< int >(val1);
5679 }
5680 if (obj1) {
5681 ecode2 = SWIG_AsVal_int(obj1, &val2);
5682 if (!SWIG_IsOK(ecode2)) {
5683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5684 }
5685 arg2 = static_cast< int >(val2);
5686 }
5687 {
5688 PyThreadState* __tstate = wxPyBeginAllowThreads();
5689 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5690 wxPyEndAllowThreads(__tstate);
5691 if (PyErr_Occurred()) SWIG_fail;
5692 }
5693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5694 return resultobj;
5695 fail:
5696 return NULL;
5697 }
5698
5699
5700 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5701 PyObject *obj;
5702 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5703 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5704 return SWIG_Py_Void();
5705 }
5706
5707 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5708 return SWIG_Python_InitShadowInstance(args);
5709 }
5710
5711 SWIGINTERN int OneString_set(PyObject *) {
5712 SWIG_Error(SWIG_AttributeError,"Variable OneString is read-only.");
5713 return 1;
5714 }
5715
5716
5717 SWIGINTERN PyObject *OneString_get(void) {
5718 PyObject *pyobj = 0;
5719
5720 {
5721 #if wxUSE_UNICODE
5722 pyobj = PyUnicode_FromWideChar((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5723 #else
5724 pyobj = PyString_FromStringAndSize((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5725 #endif
5726 }
5727 return pyobj;
5728 }
5729
5730
5731 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5732 PyObject *resultobj = 0;
5733 wxGridCellBoolEditor *result = 0 ;
5734
5735 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5736 {
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5739 wxPyEndAllowThreads(__tstate);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5743 return resultobj;
5744 fail:
5745 return NULL;
5746 }
5747
5748
5749 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_UseStringValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5750 PyObject *resultobj = 0;
5751 wxString const &arg1_defvalue = wxPyOneString ;
5752 wxString *arg1 = (wxString *) &arg1_defvalue ;
5753 wxString const &arg2_defvalue = wxPyEmptyString ;
5754 wxString *arg2 = (wxString *) &arg2_defvalue ;
5755 bool temp1 = false ;
5756 bool temp2 = false ;
5757 PyObject * obj0 = 0 ;
5758 PyObject * obj1 = 0 ;
5759 char * kwnames[] = {
5760 (char *) "valueTrue",(char *) "valueFalse", NULL
5761 };
5762
5763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:GridCellBoolEditor_UseStringValues",kwnames,&obj0,&obj1)) SWIG_fail;
5764 if (obj0) {
5765 {
5766 arg1 = wxString_in_helper(obj0);
5767 if (arg1 == NULL) SWIG_fail;
5768 temp1 = true;
5769 }
5770 }
5771 if (obj1) {
5772 {
5773 arg2 = wxString_in_helper(obj1);
5774 if (arg2 == NULL) SWIG_fail;
5775 temp2 = true;
5776 }
5777 }
5778 {
5779 PyThreadState* __tstate = wxPyBeginAllowThreads();
5780 wxGridCellBoolEditor::UseStringValues((wxString const &)*arg1,(wxString const &)*arg2);
5781 wxPyEndAllowThreads(__tstate);
5782 if (PyErr_Occurred()) SWIG_fail;
5783 }
5784 resultobj = SWIG_Py_Void();
5785 {
5786 if (temp1)
5787 delete arg1;
5788 }
5789 {
5790 if (temp2)
5791 delete arg2;
5792 }
5793 return resultobj;
5794 fail:
5795 {
5796 if (temp1)
5797 delete arg1;
5798 }
5799 {
5800 if (temp2)
5801 delete arg2;
5802 }
5803 return NULL;
5804 }
5805
5806
5807 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_IsTrueValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5808 PyObject *resultobj = 0;
5809 wxString *arg1 = 0 ;
5810 bool result;
5811 bool temp1 = false ;
5812 PyObject * obj0 = 0 ;
5813 char * kwnames[] = {
5814 (char *) "value", NULL
5815 };
5816
5817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_IsTrueValue",kwnames,&obj0)) SWIG_fail;
5818 {
5819 arg1 = wxString_in_helper(obj0);
5820 if (arg1 == NULL) SWIG_fail;
5821 temp1 = true;
5822 }
5823 {
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 result = (bool)wxGridCellBoolEditor::IsTrueValue((wxString const &)*arg1);
5826 wxPyEndAllowThreads(__tstate);
5827 if (PyErr_Occurred()) SWIG_fail;
5828 }
5829 {
5830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5831 }
5832 {
5833 if (temp1)
5834 delete arg1;
5835 }
5836 return resultobj;
5837 fail:
5838 {
5839 if (temp1)
5840 delete arg1;
5841 }
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5847 PyObject *obj;
5848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5849 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5850 return SWIG_Py_Void();
5851 }
5852
5853 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5854 return SWIG_Python_InitShadowInstance(args);
5855 }
5856
5857 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5858 PyObject *resultobj = 0;
5859 int arg1 = (int) 0 ;
5860 wxString *arg2 = (wxString *) NULL ;
5861 bool arg3 = (bool) false ;
5862 wxGridCellChoiceEditor *result = 0 ;
5863 bool val3 ;
5864 int ecode3 = 0 ;
5865 PyObject * obj0 = 0 ;
5866 PyObject * obj1 = 0 ;
5867 char * kwnames[] = {
5868 (char *) "choices",(char *) "allowOthers", NULL
5869 };
5870
5871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5872 if (obj0) {
5873 {
5874 arg1 = PyList_Size(obj0);
5875 arg2 = wxString_LIST_helper(obj0);
5876 if (arg2 == NULL) SWIG_fail;
5877 }
5878 }
5879 if (obj1) {
5880 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5881 if (!SWIG_IsOK(ecode3)) {
5882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5883 }
5884 arg3 = static_cast< bool >(val3);
5885 }
5886 {
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5893 {
5894 if (arg2) delete [] arg2;
5895 }
5896 return resultobj;
5897 fail:
5898 {
5899 if (arg2) delete [] arg2;
5900 }
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5906 PyObject *obj;
5907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5908 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5909 return SWIG_Py_Void();
5910 }
5911
5912 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5913 return SWIG_Python_InitShadowInstance(args);
5914 }
5915
5916 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj = 0;
5918 wxString const &arg1_defvalue = wxPyEmptyString ;
5919 wxString *arg1 = (wxString *) &arg1_defvalue ;
5920 wxGridCellEnumEditor *result = 0 ;
5921 bool temp1 = false ;
5922 PyObject * obj0 = 0 ;
5923 char * kwnames[] = {
5924 (char *) "choices", NULL
5925 };
5926
5927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5928 if (obj0) {
5929 {
5930 arg1 = wxString_in_helper(obj0);
5931 if (arg1 == NULL) SWIG_fail;
5932 temp1 = true;
5933 }
5934 }
5935 {
5936 PyThreadState* __tstate = wxPyBeginAllowThreads();
5937 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5938 wxPyEndAllowThreads(__tstate);
5939 if (PyErr_Occurred()) SWIG_fail;
5940 }
5941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5942 {
5943 if (temp1)
5944 delete arg1;
5945 }
5946 return resultobj;
5947 fail:
5948 {
5949 if (temp1)
5950 delete arg1;
5951 }
5952 return NULL;
5953 }
5954
5955
5956 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5957 PyObject *obj;
5958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5959 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5960 return SWIG_Py_Void();
5961 }
5962
5963 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5964 return SWIG_Python_InitShadowInstance(args);
5965 }
5966
5967 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5968 PyObject *resultobj = 0;
5969 wxGridCellAutoWrapStringEditor *result = 0 ;
5970
5971 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5972 {
5973 PyThreadState* __tstate = wxPyBeginAllowThreads();
5974 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5986 PyObject *obj;
5987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5988 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5989 return SWIG_Py_Void();
5990 }
5991
5992 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5993 return SWIG_Python_InitShadowInstance(args);
5994 }
5995
5996 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5997 PyObject *resultobj = 0;
5998 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5999 PyObject *arg2 = (PyObject *) 0 ;
6000 void *argp1 = 0 ;
6001 int res1 = 0 ;
6002 PyObject * obj0 = 0 ;
6003 PyObject * obj1 = 0 ;
6004 char * kwnames[] = {
6005 (char *) "self",(char *) "_self", NULL
6006 };
6007
6008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
6009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6010 if (!SWIG_IsOK(res1)) {
6011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6012 }
6013 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6014 arg2 = obj1;
6015 {
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 wxGridCellAttr__setOORInfo(arg1,arg2);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 resultobj = SWIG_Py_Void();
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6029 PyObject *resultobj = 0;
6030 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
6031 wxGridCellAttr *result = 0 ;
6032 void *argp1 = 0 ;
6033 int res1 = 0 ;
6034 PyObject * obj0 = 0 ;
6035 char * kwnames[] = {
6036 (char *) "attrDefault", NULL
6037 };
6038
6039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
6040 if (obj0) {
6041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6042 if (!SWIG_IsOK(res1)) {
6043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6044 }
6045 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6046 }
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 {
6054 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
6055 }
6056 return resultobj;
6057 fail:
6058 return NULL;
6059 }
6060
6061
6062 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6063 PyObject *resultobj = 0;
6064 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6065 void *argp1 = 0 ;
6066 int res1 = 0 ;
6067 PyObject *swig_obj[1] ;
6068
6069 if (!args) SWIG_fail;
6070 swig_obj[0] = args;
6071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
6072 if (!SWIG_IsOK(res1)) {
6073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6074 }
6075 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6076 {
6077 PyThreadState* __tstate = wxPyBeginAllowThreads();
6078 delete_wxGridCellAttr(arg1);
6079
6080 wxPyEndAllowThreads(__tstate);
6081 if (PyErr_Occurred()) SWIG_fail;
6082 }
6083 resultobj = SWIG_Py_Void();
6084 return resultobj;
6085 fail:
6086 return NULL;
6087 }
6088
6089
6090 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6091 PyObject *resultobj = 0;
6092 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6093 wxGridCellAttr *result = 0 ;
6094 void *argp1 = 0 ;
6095 int res1 = 0 ;
6096 PyObject *swig_obj[1] ;
6097
6098 if (!args) SWIG_fail;
6099 swig_obj[0] = args;
6100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6101 if (!SWIG_IsOK(res1)) {
6102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6103 }
6104 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6105 {
6106 PyThreadState* __tstate = wxPyBeginAllowThreads();
6107 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
6108 wxPyEndAllowThreads(__tstate);
6109 if (PyErr_Occurred()) SWIG_fail;
6110 }
6111 {
6112 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6113 }
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj = 0;
6122 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6123 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6124 void *argp1 = 0 ;
6125 int res1 = 0 ;
6126 void *argp2 = 0 ;
6127 int res2 = 0 ;
6128 PyObject * obj0 = 0 ;
6129 PyObject * obj1 = 0 ;
6130 char * kwnames[] = {
6131 (char *) "self",(char *) "mergefrom", NULL
6132 };
6133
6134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6136 if (!SWIG_IsOK(res1)) {
6137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6138 }
6139 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6141 if (!SWIG_IsOK(res2)) {
6142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6143 }
6144 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6145 {
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 (arg1)->MergeWith(arg2);
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 resultobj = SWIG_Py_Void();
6152 return resultobj;
6153 fail:
6154 return NULL;
6155 }
6156
6157
6158 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6159 PyObject *resultobj = 0;
6160 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6161 void *argp1 = 0 ;
6162 int res1 = 0 ;
6163 PyObject *swig_obj[1] ;
6164
6165 if (!args) SWIG_fail;
6166 swig_obj[0] = args;
6167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6168 if (!SWIG_IsOK(res1)) {
6169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6170 }
6171 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6172 {
6173 PyThreadState* __tstate = wxPyBeginAllowThreads();
6174 (arg1)->IncRef();
6175 wxPyEndAllowThreads(__tstate);
6176 if (PyErr_Occurred()) SWIG_fail;
6177 }
6178 resultobj = SWIG_Py_Void();
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6186 PyObject *resultobj = 0;
6187 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6188 void *argp1 = 0 ;
6189 int res1 = 0 ;
6190 PyObject *swig_obj[1] ;
6191
6192 if (!args) SWIG_fail;
6193 swig_obj[0] = args;
6194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6195 if (!SWIG_IsOK(res1)) {
6196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6197 }
6198 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6199 {
6200 PyThreadState* __tstate = wxPyBeginAllowThreads();
6201 (arg1)->DecRef();
6202 wxPyEndAllowThreads(__tstate);
6203 if (PyErr_Occurred()) SWIG_fail;
6204 }
6205 resultobj = SWIG_Py_Void();
6206 return resultobj;
6207 fail:
6208 return NULL;
6209 }
6210
6211
6212 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6213 PyObject *resultobj = 0;
6214 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6215 wxColour *arg2 = 0 ;
6216 void *argp1 = 0 ;
6217 int res1 = 0 ;
6218 wxColour temp2 ;
6219 PyObject * obj0 = 0 ;
6220 PyObject * obj1 = 0 ;
6221 char * kwnames[] = {
6222 (char *) "self",(char *) "colText", NULL
6223 };
6224
6225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6227 if (!SWIG_IsOK(res1)) {
6228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6229 }
6230 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6231 {
6232 arg2 = &temp2;
6233 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6234 }
6235 {
6236 PyThreadState* __tstate = wxPyBeginAllowThreads();
6237 (arg1)->SetTextColour((wxColour const &)*arg2);
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 resultobj = SWIG_Py_Void();
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6249 PyObject *resultobj = 0;
6250 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6251 wxColour *arg2 = 0 ;
6252 void *argp1 = 0 ;
6253 int res1 = 0 ;
6254 wxColour temp2 ;
6255 PyObject * obj0 = 0 ;
6256 PyObject * obj1 = 0 ;
6257 char * kwnames[] = {
6258 (char *) "self",(char *) "colBack", NULL
6259 };
6260
6261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
6262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6263 if (!SWIG_IsOK(res1)) {
6264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6265 }
6266 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6267 {
6268 arg2 = &temp2;
6269 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6270 }
6271 {
6272 PyThreadState* __tstate = wxPyBeginAllowThreads();
6273 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6274 wxPyEndAllowThreads(__tstate);
6275 if (PyErr_Occurred()) SWIG_fail;
6276 }
6277 resultobj = SWIG_Py_Void();
6278 return resultobj;
6279 fail:
6280 return NULL;
6281 }
6282
6283
6284 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6285 PyObject *resultobj = 0;
6286 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6287 wxFont *arg2 = 0 ;
6288 void *argp1 = 0 ;
6289 int res1 = 0 ;
6290 void *argp2 = 0 ;
6291 int res2 = 0 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 char * kwnames[] = {
6295 (char *) "self",(char *) "font", NULL
6296 };
6297
6298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6300 if (!SWIG_IsOK(res1)) {
6301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6302 }
6303 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6305 if (!SWIG_IsOK(res2)) {
6306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6307 }
6308 if (!argp2) {
6309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6310 }
6311 arg2 = reinterpret_cast< wxFont * >(argp2);
6312 {
6313 PyThreadState* __tstate = wxPyBeginAllowThreads();
6314 (arg1)->SetFont((wxFont const &)*arg2);
6315 wxPyEndAllowThreads(__tstate);
6316 if (PyErr_Occurred()) SWIG_fail;
6317 }
6318 resultobj = SWIG_Py_Void();
6319 return resultobj;
6320 fail:
6321 return NULL;
6322 }
6323
6324
6325 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6326 PyObject *resultobj = 0;
6327 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6328 int arg2 ;
6329 int arg3 ;
6330 void *argp1 = 0 ;
6331 int res1 = 0 ;
6332 int val2 ;
6333 int ecode2 = 0 ;
6334 int val3 ;
6335 int ecode3 = 0 ;
6336 PyObject * obj0 = 0 ;
6337 PyObject * obj1 = 0 ;
6338 PyObject * obj2 = 0 ;
6339 char * kwnames[] = {
6340 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6341 };
6342
6343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6345 if (!SWIG_IsOK(res1)) {
6346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6347 }
6348 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6349 ecode2 = SWIG_AsVal_int(obj1, &val2);
6350 if (!SWIG_IsOK(ecode2)) {
6351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6352 }
6353 arg2 = static_cast< int >(val2);
6354 ecode3 = SWIG_AsVal_int(obj2, &val3);
6355 if (!SWIG_IsOK(ecode3)) {
6356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6357 }
6358 arg3 = static_cast< int >(val3);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 (arg1)->SetAlignment(arg2,arg3);
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_Py_Void();
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6375 int arg2 ;
6376 int arg3 ;
6377 void *argp1 = 0 ;
6378 int res1 = 0 ;
6379 int val2 ;
6380 int ecode2 = 0 ;
6381 int val3 ;
6382 int ecode3 = 0 ;
6383 PyObject * obj0 = 0 ;
6384 PyObject * obj1 = 0 ;
6385 PyObject * obj2 = 0 ;
6386 char * kwnames[] = {
6387 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6388 };
6389
6390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6392 if (!SWIG_IsOK(res1)) {
6393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6394 }
6395 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6396 ecode2 = SWIG_AsVal_int(obj1, &val2);
6397 if (!SWIG_IsOK(ecode2)) {
6398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6399 }
6400 arg2 = static_cast< int >(val2);
6401 ecode3 = SWIG_AsVal_int(obj2, &val3);
6402 if (!SWIG_IsOK(ecode3)) {
6403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6404 }
6405 arg3 = static_cast< int >(val3);
6406 {
6407 PyThreadState* __tstate = wxPyBeginAllowThreads();
6408 (arg1)->SetSize(arg2,arg3);
6409 wxPyEndAllowThreads(__tstate);
6410 if (PyErr_Occurred()) SWIG_fail;
6411 }
6412 resultobj = SWIG_Py_Void();
6413 return resultobj;
6414 fail:
6415 return NULL;
6416 }
6417
6418
6419 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6420 PyObject *resultobj = 0;
6421 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6422 bool arg2 = (bool) true ;
6423 void *argp1 = 0 ;
6424 int res1 = 0 ;
6425 bool val2 ;
6426 int ecode2 = 0 ;
6427 PyObject * obj0 = 0 ;
6428 PyObject * obj1 = 0 ;
6429 char * kwnames[] = {
6430 (char *) "self",(char *) "allow", NULL
6431 };
6432
6433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6437 }
6438 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6439 if (obj1) {
6440 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6441 if (!SWIG_IsOK(ecode2)) {
6442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6443 }
6444 arg2 = static_cast< bool >(val2);
6445 }
6446 {
6447 PyThreadState* __tstate = wxPyBeginAllowThreads();
6448 (arg1)->SetOverflow(arg2);
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = SWIG_Py_Void();
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6460 PyObject *resultobj = 0;
6461 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6462 bool arg2 = (bool) true ;
6463 void *argp1 = 0 ;
6464 int res1 = 0 ;
6465 bool val2 ;
6466 int ecode2 = 0 ;
6467 PyObject * obj0 = 0 ;
6468 PyObject * obj1 = 0 ;
6469 char * kwnames[] = {
6470 (char *) "self",(char *) "isReadOnly", NULL
6471 };
6472
6473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6475 if (!SWIG_IsOK(res1)) {
6476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6477 }
6478 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6479 if (obj1) {
6480 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6481 if (!SWIG_IsOK(ecode2)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6483 }
6484 arg2 = static_cast< bool >(val2);
6485 }
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 (arg1)->SetReadOnly(arg2);
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = SWIG_Py_Void();
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj = 0;
6501 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6502 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6503 void *argp1 = 0 ;
6504 int res1 = 0 ;
6505 void *argp2 = 0 ;
6506 int res2 = 0 ;
6507 PyObject * obj0 = 0 ;
6508 PyObject * obj1 = 0 ;
6509 char * kwnames[] = {
6510 (char *) "self",(char *) "renderer", NULL
6511 };
6512
6513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6515 if (!SWIG_IsOK(res1)) {
6516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6517 }
6518 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6520 if (!SWIG_IsOK(res2)) {
6521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6522 }
6523 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6524 {
6525 PyThreadState* __tstate = wxPyBeginAllowThreads();
6526 (arg1)->SetRenderer(arg2);
6527 wxPyEndAllowThreads(__tstate);
6528 if (PyErr_Occurred()) SWIG_fail;
6529 }
6530 resultobj = SWIG_Py_Void();
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj = 0;
6539 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6540 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6541 void *argp1 = 0 ;
6542 int res1 = 0 ;
6543 void *argp2 = 0 ;
6544 int res2 = 0 ;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 char * kwnames[] = {
6548 (char *) "self",(char *) "editor", NULL
6549 };
6550
6551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6555 }
6556 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6558 if (!SWIG_IsOK(res2)) {
6559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6560 }
6561 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6562 {
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 (arg1)->SetEditor(arg2);
6565 wxPyEndAllowThreads(__tstate);
6566 if (PyErr_Occurred()) SWIG_fail;
6567 }
6568 resultobj = SWIG_Py_Void();
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6576 PyObject *resultobj = 0;
6577 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6578 wxGridCellAttr::wxAttrKind arg2 ;
6579 void *argp1 = 0 ;
6580 int res1 = 0 ;
6581 int val2 ;
6582 int ecode2 = 0 ;
6583 PyObject * obj0 = 0 ;
6584 PyObject * obj1 = 0 ;
6585 char * kwnames[] = {
6586 (char *) "self",(char *) "kind", NULL
6587 };
6588
6589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6591 if (!SWIG_IsOK(res1)) {
6592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6593 }
6594 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6595 ecode2 = SWIG_AsVal_int(obj1, &val2);
6596 if (!SWIG_IsOK(ecode2)) {
6597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6598 }
6599 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6600 {
6601 PyThreadState* __tstate = wxPyBeginAllowThreads();
6602 (arg1)->SetKind(arg2);
6603 wxPyEndAllowThreads(__tstate);
6604 if (PyErr_Occurred()) SWIG_fail;
6605 }
6606 resultobj = SWIG_Py_Void();
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6614 PyObject *resultobj = 0;
6615 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6616 bool result;
6617 void *argp1 = 0 ;
6618 int res1 = 0 ;
6619 PyObject *swig_obj[1] ;
6620
6621 if (!args) SWIG_fail;
6622 swig_obj[0] = args;
6623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6624 if (!SWIG_IsOK(res1)) {
6625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6626 }
6627 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6628 {
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6631 wxPyEndAllowThreads(__tstate);
6632 if (PyErr_Occurred()) SWIG_fail;
6633 }
6634 {
6635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6636 }
6637 return resultobj;
6638 fail:
6639 return NULL;
6640 }
6641
6642
6643 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6644 PyObject *resultobj = 0;
6645 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6646 bool result;
6647 void *argp1 = 0 ;
6648 int res1 = 0 ;
6649 PyObject *swig_obj[1] ;
6650
6651 if (!args) SWIG_fail;
6652 swig_obj[0] = args;
6653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6654 if (!SWIG_IsOK(res1)) {
6655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6656 }
6657 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6658 {
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 {
6665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6666 }
6667 return resultobj;
6668 fail:
6669 return NULL;
6670 }
6671
6672
6673 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6674 PyObject *resultobj = 0;
6675 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6676 bool result;
6677 void *argp1 = 0 ;
6678 int res1 = 0 ;
6679 PyObject *swig_obj[1] ;
6680
6681 if (!args) SWIG_fail;
6682 swig_obj[0] = args;
6683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6684 if (!SWIG_IsOK(res1)) {
6685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6686 }
6687 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6688 {
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 {
6695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6696 }
6697 return resultobj;
6698 fail:
6699 return NULL;
6700 }
6701
6702
6703 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6704 PyObject *resultobj = 0;
6705 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6706 bool result;
6707 void *argp1 = 0 ;
6708 int res1 = 0 ;
6709 PyObject *swig_obj[1] ;
6710
6711 if (!args) SWIG_fail;
6712 swig_obj[0] = args;
6713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6714 if (!SWIG_IsOK(res1)) {
6715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6716 }
6717 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6718 {
6719 PyThreadState* __tstate = wxPyBeginAllowThreads();
6720 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6721 wxPyEndAllowThreads(__tstate);
6722 if (PyErr_Occurred()) SWIG_fail;
6723 }
6724 {
6725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6726 }
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6734 PyObject *resultobj = 0;
6735 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6736 bool result;
6737 void *argp1 = 0 ;
6738 int res1 = 0 ;
6739 PyObject *swig_obj[1] ;
6740
6741 if (!args) SWIG_fail;
6742 swig_obj[0] = args;
6743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6744 if (!SWIG_IsOK(res1)) {
6745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6746 }
6747 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6748 {
6749 PyThreadState* __tstate = wxPyBeginAllowThreads();
6750 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6751 wxPyEndAllowThreads(__tstate);
6752 if (PyErr_Occurred()) SWIG_fail;
6753 }
6754 {
6755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6756 }
6757 return resultobj;
6758 fail:
6759 return NULL;
6760 }
6761
6762
6763 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6764 PyObject *resultobj = 0;
6765 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6766 bool result;
6767 void *argp1 = 0 ;
6768 int res1 = 0 ;
6769 PyObject *swig_obj[1] ;
6770
6771 if (!args) SWIG_fail;
6772 swig_obj[0] = args;
6773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6774 if (!SWIG_IsOK(res1)) {
6775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6776 }
6777 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 {
6785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6786 }
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6794 PyObject *resultobj = 0;
6795 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6796 bool result;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 PyObject *swig_obj[1] ;
6800
6801 if (!args) SWIG_fail;
6802 swig_obj[0] = args;
6803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6804 if (!SWIG_IsOK(res1)) {
6805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6806 }
6807 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6808 {
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 {
6815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6816 }
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6824 PyObject *resultobj = 0;
6825 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6826 bool result;
6827 void *argp1 = 0 ;
6828 int res1 = 0 ;
6829 PyObject *swig_obj[1] ;
6830
6831 if (!args) SWIG_fail;
6832 swig_obj[0] = args;
6833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6834 if (!SWIG_IsOK(res1)) {
6835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6836 }
6837 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6838 {
6839 PyThreadState* __tstate = wxPyBeginAllowThreads();
6840 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6841 wxPyEndAllowThreads(__tstate);
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 {
6845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6846 }
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6854 PyObject *resultobj = 0;
6855 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6856 wxColour result;
6857 void *argp1 = 0 ;
6858 int res1 = 0 ;
6859 PyObject *swig_obj[1] ;
6860
6861 if (!args) SWIG_fail;
6862 swig_obj[0] = args;
6863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6864 if (!SWIG_IsOK(res1)) {
6865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6866 }
6867 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6868 {
6869 PyThreadState* __tstate = wxPyBeginAllowThreads();
6870 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6882 PyObject *resultobj = 0;
6883 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6884 wxColour result;
6885 void *argp1 = 0 ;
6886 int res1 = 0 ;
6887 PyObject *swig_obj[1] ;
6888
6889 if (!args) SWIG_fail;
6890 swig_obj[0] = args;
6891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6892 if (!SWIG_IsOK(res1)) {
6893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6894 }
6895 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6896 {
6897 PyThreadState* __tstate = wxPyBeginAllowThreads();
6898 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6899 wxPyEndAllowThreads(__tstate);
6900 if (PyErr_Occurred()) SWIG_fail;
6901 }
6902 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6903 return resultobj;
6904 fail:
6905 return NULL;
6906 }
6907
6908
6909 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6910 PyObject *resultobj = 0;
6911 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6912 wxFont result;
6913 void *argp1 = 0 ;
6914 int res1 = 0 ;
6915 PyObject *swig_obj[1] ;
6916
6917 if (!args) SWIG_fail;
6918 swig_obj[0] = args;
6919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6920 if (!SWIG_IsOK(res1)) {
6921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6922 }
6923 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 result = ((wxGridCellAttr const *)arg1)->GetFont();
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6938 PyObject *resultobj = 0;
6939 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6940 int *arg2 = (int *) 0 ;
6941 int *arg3 = (int *) 0 ;
6942 void *argp1 = 0 ;
6943 int res1 = 0 ;
6944 int temp2 ;
6945 int res2 = SWIG_TMPOBJ ;
6946 int temp3 ;
6947 int res3 = SWIG_TMPOBJ ;
6948 PyObject *swig_obj[1] ;
6949
6950 arg2 = &temp2;
6951 arg3 = &temp3;
6952 if (!args) SWIG_fail;
6953 swig_obj[0] = args;
6954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6955 if (!SWIG_IsOK(res1)) {
6956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6957 }
6958 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6959 {
6960 PyThreadState* __tstate = wxPyBeginAllowThreads();
6961 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_Py_Void();
6966 if (SWIG_IsTmpObj(res2)) {
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6968 } else {
6969 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6971 }
6972 if (SWIG_IsTmpObj(res3)) {
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6974 } else {
6975 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6977 }
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6985 PyObject *resultobj = 0;
6986 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6987 int *arg2 = (int *) 0 ;
6988 int *arg3 = (int *) 0 ;
6989 void *argp1 = 0 ;
6990 int res1 = 0 ;
6991 int temp2 ;
6992 int res2 = SWIG_TMPOBJ ;
6993 int temp3 ;
6994 int res3 = SWIG_TMPOBJ ;
6995 PyObject *swig_obj[1] ;
6996
6997 arg2 = &temp2;
6998 arg3 = &temp3;
6999 if (!args) SWIG_fail;
7000 swig_obj[0] = args;
7001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7002 if (!SWIG_IsOK(res1)) {
7003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7004 }
7005 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7006 {
7007 PyThreadState* __tstate = wxPyBeginAllowThreads();
7008 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
7009 wxPyEndAllowThreads(__tstate);
7010 if (PyErr_Occurred()) SWIG_fail;
7011 }
7012 resultobj = SWIG_Py_Void();
7013 if (SWIG_IsTmpObj(res2)) {
7014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7015 } else {
7016 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7018 }
7019 if (SWIG_IsTmpObj(res3)) {
7020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7021 } else {
7022 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7023 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7024 }
7025 return resultobj;
7026 fail:
7027 return NULL;
7028 }
7029
7030
7031 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7032 PyObject *resultobj = 0;
7033 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7034 bool result;
7035 void *argp1 = 0 ;
7036 int res1 = 0 ;
7037 PyObject *swig_obj[1] ;
7038
7039 if (!args) SWIG_fail;
7040 swig_obj[0] = args;
7041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7042 if (!SWIG_IsOK(res1)) {
7043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7044 }
7045 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 {
7053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7054 }
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7062 PyObject *resultobj = 0;
7063 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7064 wxGrid *arg2 = (wxGrid *) 0 ;
7065 int arg3 ;
7066 int arg4 ;
7067 wxGridCellRenderer *result = 0 ;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 void *argp2 = 0 ;
7071 int res2 = 0 ;
7072 int val3 ;
7073 int ecode3 = 0 ;
7074 int val4 ;
7075 int ecode4 = 0 ;
7076 PyObject * obj0 = 0 ;
7077 PyObject * obj1 = 0 ;
7078 PyObject * obj2 = 0 ;
7079 PyObject * obj3 = 0 ;
7080 char * kwnames[] = {
7081 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7082 };
7083
7084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7088 }
7089 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7091 if (!SWIG_IsOK(res2)) {
7092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
7093 }
7094 arg2 = reinterpret_cast< wxGrid * >(argp2);
7095 ecode3 = SWIG_AsVal_int(obj2, &val3);
7096 if (!SWIG_IsOK(ecode3)) {
7097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
7098 }
7099 arg3 = static_cast< int >(val3);
7100 ecode4 = SWIG_AsVal_int(obj3, &val4);
7101 if (!SWIG_IsOK(ecode4)) {
7102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
7103 }
7104 arg4 = static_cast< int >(val4);
7105 {
7106 PyThreadState* __tstate = wxPyBeginAllowThreads();
7107 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
7108 wxPyEndAllowThreads(__tstate);
7109 if (PyErr_Occurred()) SWIG_fail;
7110 }
7111 {
7112 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
7113 }
7114 return resultobj;
7115 fail:
7116 return NULL;
7117 }
7118
7119
7120 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7121 PyObject *resultobj = 0;
7122 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7123 wxGrid *arg2 = (wxGrid *) 0 ;
7124 int arg3 ;
7125 int arg4 ;
7126 wxGridCellEditor *result = 0 ;
7127 void *argp1 = 0 ;
7128 int res1 = 0 ;
7129 void *argp2 = 0 ;
7130 int res2 = 0 ;
7131 int val3 ;
7132 int ecode3 = 0 ;
7133 int val4 ;
7134 int ecode4 = 0 ;
7135 PyObject * obj0 = 0 ;
7136 PyObject * obj1 = 0 ;
7137 PyObject * obj2 = 0 ;
7138 PyObject * obj3 = 0 ;
7139 char * kwnames[] = {
7140 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7141 };
7142
7143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7145 if (!SWIG_IsOK(res1)) {
7146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7147 }
7148 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7150 if (!SWIG_IsOK(res2)) {
7151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7152 }
7153 arg2 = reinterpret_cast< wxGrid * >(argp2);
7154 ecode3 = SWIG_AsVal_int(obj2, &val3);
7155 if (!SWIG_IsOK(ecode3)) {
7156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7157 }
7158 arg3 = static_cast< int >(val3);
7159 ecode4 = SWIG_AsVal_int(obj3, &val4);
7160 if (!SWIG_IsOK(ecode4)) {
7161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7162 }
7163 arg4 = static_cast< int >(val4);
7164 {
7165 PyThreadState* __tstate = wxPyBeginAllowThreads();
7166 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7167 wxPyEndAllowThreads(__tstate);
7168 if (PyErr_Occurred()) SWIG_fail;
7169 }
7170 {
7171 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7172 }
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7180 PyObject *resultobj = 0;
7181 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7182 bool result;
7183 void *argp1 = 0 ;
7184 int res1 = 0 ;
7185 PyObject *swig_obj[1] ;
7186
7187 if (!args) SWIG_fail;
7188 swig_obj[0] = args;
7189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7190 if (!SWIG_IsOK(res1)) {
7191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7192 }
7193 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7194 {
7195 PyThreadState* __tstate = wxPyBeginAllowThreads();
7196 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7197 wxPyEndAllowThreads(__tstate);
7198 if (PyErr_Occurred()) SWIG_fail;
7199 }
7200 {
7201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7202 }
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7210 PyObject *resultobj = 0;
7211 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7212 wxGridCellAttr::wxAttrKind result;
7213 void *argp1 = 0 ;
7214 int res1 = 0 ;
7215 PyObject *swig_obj[1] ;
7216
7217 if (!args) SWIG_fail;
7218 swig_obj[0] = args;
7219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7220 if (!SWIG_IsOK(res1)) {
7221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7222 }
7223 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7224 {
7225 PyThreadState* __tstate = wxPyBeginAllowThreads();
7226 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7227 wxPyEndAllowThreads(__tstate);
7228 if (PyErr_Occurred()) SWIG_fail;
7229 }
7230 resultobj = SWIG_From_int(static_cast< int >(result));
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj = 0;
7239 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7240 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7241 void *argp1 = 0 ;
7242 int res1 = 0 ;
7243 void *argp2 = 0 ;
7244 int res2 = 0 ;
7245 PyObject * obj0 = 0 ;
7246 PyObject * obj1 = 0 ;
7247 char * kwnames[] = {
7248 (char *) "self",(char *) "defAttr", NULL
7249 };
7250
7251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7253 if (!SWIG_IsOK(res1)) {
7254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7255 }
7256 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7258 if (!SWIG_IsOK(res2)) {
7259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7260 }
7261 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7262 {
7263 PyThreadState* __tstate = wxPyBeginAllowThreads();
7264 (arg1)->SetDefAttr(arg2);
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 *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7276 PyObject *obj;
7277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7278 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7279 return SWIG_Py_Void();
7280 }
7281
7282 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7283 return SWIG_Python_InitShadowInstance(args);
7284 }
7285
7286 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7287 PyObject *resultobj = 0;
7288 wxGridCellAttrProvider *result = 0 ;
7289
7290 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7291 {
7292 PyThreadState* __tstate = wxPyBeginAllowThreads();
7293 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7294 wxPyEndAllowThreads(__tstate);
7295 if (PyErr_Occurred()) SWIG_fail;
7296 }
7297 {
7298 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7299 }
7300 return resultobj;
7301 fail:
7302 return NULL;
7303 }
7304
7305
7306 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7307 PyObject *resultobj = 0;
7308 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7309 PyObject *arg2 = (PyObject *) 0 ;
7310 void *argp1 = 0 ;
7311 int res1 = 0 ;
7312 PyObject * obj0 = 0 ;
7313 PyObject * obj1 = 0 ;
7314 char * kwnames[] = {
7315 (char *) "self",(char *) "_self", NULL
7316 };
7317
7318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7320 if (!SWIG_IsOK(res1)) {
7321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7322 }
7323 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7324 arg2 = obj1;
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 resultobj = SWIG_Py_Void();
7332 return resultobj;
7333 fail:
7334 return NULL;
7335 }
7336
7337
7338 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7339 PyObject *resultobj = 0;
7340 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7341 int arg2 ;
7342 int arg3 ;
7343 wxGridCellAttr::wxAttrKind arg4 ;
7344 wxGridCellAttr *result = 0 ;
7345 void *argp1 = 0 ;
7346 int res1 = 0 ;
7347 int val2 ;
7348 int ecode2 = 0 ;
7349 int val3 ;
7350 int ecode3 = 0 ;
7351 int val4 ;
7352 int ecode4 = 0 ;
7353 PyObject * obj0 = 0 ;
7354 PyObject * obj1 = 0 ;
7355 PyObject * obj2 = 0 ;
7356 PyObject * obj3 = 0 ;
7357 char * kwnames[] = {
7358 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7359 };
7360
7361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7363 if (!SWIG_IsOK(res1)) {
7364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7365 }
7366 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7367 ecode2 = SWIG_AsVal_int(obj1, &val2);
7368 if (!SWIG_IsOK(ecode2)) {
7369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7370 }
7371 arg2 = static_cast< int >(val2);
7372 ecode3 = SWIG_AsVal_int(obj2, &val3);
7373 if (!SWIG_IsOK(ecode3)) {
7374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7375 }
7376 arg3 = static_cast< int >(val3);
7377 ecode4 = SWIG_AsVal_int(obj3, &val4);
7378 if (!SWIG_IsOK(ecode4)) {
7379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7380 }
7381 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7382 {
7383 PyThreadState* __tstate = wxPyBeginAllowThreads();
7384 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7385 wxPyEndAllowThreads(__tstate);
7386 if (PyErr_Occurred()) SWIG_fail;
7387 }
7388 {
7389 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7390 }
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj = 0;
7399 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7400 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7401 int arg3 ;
7402 int arg4 ;
7403 void *argp1 = 0 ;
7404 int res1 = 0 ;
7405 void *argp2 = 0 ;
7406 int res2 = 0 ;
7407 int val3 ;
7408 int ecode3 = 0 ;
7409 int val4 ;
7410 int ecode4 = 0 ;
7411 PyObject * obj0 = 0 ;
7412 PyObject * obj1 = 0 ;
7413 PyObject * obj2 = 0 ;
7414 PyObject * obj3 = 0 ;
7415 char * kwnames[] = {
7416 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7417 };
7418
7419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7421 if (!SWIG_IsOK(res1)) {
7422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7423 }
7424 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7426 if (!SWIG_IsOK(res2)) {
7427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7428 }
7429 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7430 ecode3 = SWIG_AsVal_int(obj2, &val3);
7431 if (!SWIG_IsOK(ecode3)) {
7432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7433 }
7434 arg3 = static_cast< int >(val3);
7435 ecode4 = SWIG_AsVal_int(obj3, &val4);
7436 if (!SWIG_IsOK(ecode4)) {
7437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7438 }
7439 arg4 = static_cast< int >(val4);
7440 {
7441 PyThreadState* __tstate = wxPyBeginAllowThreads();
7442 (arg1)->SetAttr(arg2,arg3,arg4);
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 resultobj = SWIG_Py_Void();
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj = 0;
7455 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7456 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7457 int arg3 ;
7458 void *argp1 = 0 ;
7459 int res1 = 0 ;
7460 void *argp2 = 0 ;
7461 int res2 = 0 ;
7462 int val3 ;
7463 int ecode3 = 0 ;
7464 PyObject * obj0 = 0 ;
7465 PyObject * obj1 = 0 ;
7466 PyObject * obj2 = 0 ;
7467 char * kwnames[] = {
7468 (char *) "self",(char *) "attr",(char *) "row", NULL
7469 };
7470
7471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7473 if (!SWIG_IsOK(res1)) {
7474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7475 }
7476 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7478 if (!SWIG_IsOK(res2)) {
7479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7480 }
7481 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7482 ecode3 = SWIG_AsVal_int(obj2, &val3);
7483 if (!SWIG_IsOK(ecode3)) {
7484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7485 }
7486 arg3 = static_cast< int >(val3);
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 (arg1)->SetRowAttr(arg2,arg3);
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 resultobj = SWIG_Py_Void();
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj = 0;
7502 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7503 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7504 int arg3 ;
7505 void *argp1 = 0 ;
7506 int res1 = 0 ;
7507 void *argp2 = 0 ;
7508 int res2 = 0 ;
7509 int val3 ;
7510 int ecode3 = 0 ;
7511 PyObject * obj0 = 0 ;
7512 PyObject * obj1 = 0 ;
7513 PyObject * obj2 = 0 ;
7514 char * kwnames[] = {
7515 (char *) "self",(char *) "attr",(char *) "col", NULL
7516 };
7517
7518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7520 if (!SWIG_IsOK(res1)) {
7521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7522 }
7523 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7525 if (!SWIG_IsOK(res2)) {
7526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7527 }
7528 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7529 ecode3 = SWIG_AsVal_int(obj2, &val3);
7530 if (!SWIG_IsOK(ecode3)) {
7531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7532 }
7533 arg3 = static_cast< int >(val3);
7534 {
7535 PyThreadState* __tstate = wxPyBeginAllowThreads();
7536 (arg1)->SetColAttr(arg2,arg3);
7537 wxPyEndAllowThreads(__tstate);
7538 if (PyErr_Occurred()) SWIG_fail;
7539 }
7540 resultobj = SWIG_Py_Void();
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7548 PyObject *resultobj = 0;
7549 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7550 size_t arg2 ;
7551 int arg3 ;
7552 void *argp1 = 0 ;
7553 int res1 = 0 ;
7554 size_t val2 ;
7555 int ecode2 = 0 ;
7556 int val3 ;
7557 int ecode3 = 0 ;
7558 PyObject * obj0 = 0 ;
7559 PyObject * obj1 = 0 ;
7560 PyObject * obj2 = 0 ;
7561 char * kwnames[] = {
7562 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7563 };
7564
7565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7567 if (!SWIG_IsOK(res1)) {
7568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7569 }
7570 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7571 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7572 if (!SWIG_IsOK(ecode2)) {
7573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7574 }
7575 arg2 = static_cast< size_t >(val2);
7576 ecode3 = SWIG_AsVal_int(obj2, &val3);
7577 if (!SWIG_IsOK(ecode3)) {
7578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7579 }
7580 arg3 = static_cast< int >(val3);
7581 {
7582 PyThreadState* __tstate = wxPyBeginAllowThreads();
7583 (arg1)->UpdateAttrRows(arg2,arg3);
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 resultobj = SWIG_Py_Void();
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj = 0;
7596 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7597 size_t arg2 ;
7598 int arg3 ;
7599 void *argp1 = 0 ;
7600 int res1 = 0 ;
7601 size_t val2 ;
7602 int ecode2 = 0 ;
7603 int val3 ;
7604 int ecode3 = 0 ;
7605 PyObject * obj0 = 0 ;
7606 PyObject * obj1 = 0 ;
7607 PyObject * obj2 = 0 ;
7608 char * kwnames[] = {
7609 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7610 };
7611
7612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7614 if (!SWIG_IsOK(res1)) {
7615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7616 }
7617 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7618 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7619 if (!SWIG_IsOK(ecode2)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7621 }
7622 arg2 = static_cast< size_t >(val2);
7623 ecode3 = SWIG_AsVal_int(obj2, &val3);
7624 if (!SWIG_IsOK(ecode3)) {
7625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7626 }
7627 arg3 = static_cast< int >(val3);
7628 {
7629 PyThreadState* __tstate = wxPyBeginAllowThreads();
7630 (arg1)->UpdateAttrCols(arg2,arg3);
7631 wxPyEndAllowThreads(__tstate);
7632 if (PyErr_Occurred()) SWIG_fail;
7633 }
7634 resultobj = SWIG_Py_Void();
7635 return resultobj;
7636 fail:
7637 return NULL;
7638 }
7639
7640
7641 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7642 PyObject *obj;
7643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7644 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7645 return SWIG_Py_Void();
7646 }
7647
7648 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7649 return SWIG_Python_InitShadowInstance(args);
7650 }
7651
7652 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7653 PyObject *resultobj = 0;
7654 wxPyGridCellAttrProvider *result = 0 ;
7655
7656 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7657 {
7658 PyThreadState* __tstate = wxPyBeginAllowThreads();
7659 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj = 0;
7672 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7673 PyObject *arg2 = (PyObject *) 0 ;
7674 PyObject *arg3 = (PyObject *) 0 ;
7675 void *argp1 = 0 ;
7676 int res1 = 0 ;
7677 PyObject * obj0 = 0 ;
7678 PyObject * obj1 = 0 ;
7679 PyObject * obj2 = 0 ;
7680 char * kwnames[] = {
7681 (char *) "self",(char *) "self",(char *) "_class", NULL
7682 };
7683
7684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7686 if (!SWIG_IsOK(res1)) {
7687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7688 }
7689 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7690 arg2 = obj1;
7691 arg3 = obj2;
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 (arg1)->_setCallbackInfo(arg2,arg3);
7695 wxPyEndAllowThreads(__tstate);
7696 if (PyErr_Occurred()) SWIG_fail;
7697 }
7698 resultobj = SWIG_Py_Void();
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj = 0;
7707 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7708 int arg2 ;
7709 int arg3 ;
7710 wxGridCellAttr::wxAttrKind arg4 ;
7711 wxGridCellAttr *result = 0 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 int val3 ;
7717 int ecode3 = 0 ;
7718 int val4 ;
7719 int ecode4 = 0 ;
7720 PyObject * obj0 = 0 ;
7721 PyObject * obj1 = 0 ;
7722 PyObject * obj2 = 0 ;
7723 PyObject * obj3 = 0 ;
7724 char * kwnames[] = {
7725 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7726 };
7727
7728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7730 if (!SWIG_IsOK(res1)) {
7731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7732 }
7733 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7734 ecode2 = SWIG_AsVal_int(obj1, &val2);
7735 if (!SWIG_IsOK(ecode2)) {
7736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7737 }
7738 arg2 = static_cast< int >(val2);
7739 ecode3 = SWIG_AsVal_int(obj2, &val3);
7740 if (!SWIG_IsOK(ecode3)) {
7741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7742 }
7743 arg3 = static_cast< int >(val3);
7744 ecode4 = SWIG_AsVal_int(obj3, &val4);
7745 if (!SWIG_IsOK(ecode4)) {
7746 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7747 }
7748 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7749 {
7750 PyThreadState* __tstate = wxPyBeginAllowThreads();
7751 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7752 wxPyEndAllowThreads(__tstate);
7753 if (PyErr_Occurred()) SWIG_fail;
7754 }
7755 {
7756 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7757 }
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
7764 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7765 PyObject *resultobj = 0;
7766 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7767 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7768 int arg3 ;
7769 int arg4 ;
7770 void *argp1 = 0 ;
7771 int res1 = 0 ;
7772 void *argp2 = 0 ;
7773 int res2 = 0 ;
7774 int val3 ;
7775 int ecode3 = 0 ;
7776 int val4 ;
7777 int ecode4 = 0 ;
7778 PyObject * obj0 = 0 ;
7779 PyObject * obj1 = 0 ;
7780 PyObject * obj2 = 0 ;
7781 PyObject * obj3 = 0 ;
7782 char * kwnames[] = {
7783 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7784 };
7785
7786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7788 if (!SWIG_IsOK(res1)) {
7789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7790 }
7791 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7793 if (!SWIG_IsOK(res2)) {
7794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7795 }
7796 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7797 ecode3 = SWIG_AsVal_int(obj2, &val3);
7798 if (!SWIG_IsOK(ecode3)) {
7799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7800 }
7801 arg3 = static_cast< int >(val3);
7802 ecode4 = SWIG_AsVal_int(obj3, &val4);
7803 if (!SWIG_IsOK(ecode4)) {
7804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7805 }
7806 arg4 = static_cast< int >(val4);
7807 {
7808 PyThreadState* __tstate = wxPyBeginAllowThreads();
7809 (arg1)->SetAttr(arg2,arg3,arg4);
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 resultobj = SWIG_Py_Void();
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj = 0;
7822 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7823 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7824 int arg3 ;
7825 void *argp1 = 0 ;
7826 int res1 = 0 ;
7827 void *argp2 = 0 ;
7828 int res2 = 0 ;
7829 int val3 ;
7830 int ecode3 = 0 ;
7831 PyObject * obj0 = 0 ;
7832 PyObject * obj1 = 0 ;
7833 PyObject * obj2 = 0 ;
7834 char * kwnames[] = {
7835 (char *) "self",(char *) "attr",(char *) "row", NULL
7836 };
7837
7838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7840 if (!SWIG_IsOK(res1)) {
7841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7842 }
7843 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7844 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7845 if (!SWIG_IsOK(res2)) {
7846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7847 }
7848 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7849 ecode3 = SWIG_AsVal_int(obj2, &val3);
7850 if (!SWIG_IsOK(ecode3)) {
7851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7852 }
7853 arg3 = static_cast< int >(val3);
7854 {
7855 PyThreadState* __tstate = wxPyBeginAllowThreads();
7856 (arg1)->SetRowAttr(arg2,arg3);
7857 wxPyEndAllowThreads(__tstate);
7858 if (PyErr_Occurred()) SWIG_fail;
7859 }
7860 resultobj = SWIG_Py_Void();
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7868 PyObject *resultobj = 0;
7869 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7870 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7871 int arg3 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 void *argp2 = 0 ;
7875 int res2 = 0 ;
7876 int val3 ;
7877 int ecode3 = 0 ;
7878 PyObject * obj0 = 0 ;
7879 PyObject * obj1 = 0 ;
7880 PyObject * obj2 = 0 ;
7881 char * kwnames[] = {
7882 (char *) "self",(char *) "attr",(char *) "col", NULL
7883 };
7884
7885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7887 if (!SWIG_IsOK(res1)) {
7888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7889 }
7890 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7892 if (!SWIG_IsOK(res2)) {
7893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7894 }
7895 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7896 ecode3 = SWIG_AsVal_int(obj2, &val3);
7897 if (!SWIG_IsOK(ecode3)) {
7898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7899 }
7900 arg3 = static_cast< int >(val3);
7901 {
7902 PyThreadState* __tstate = wxPyBeginAllowThreads();
7903 (arg1)->SetColAttr(arg2,arg3);
7904 wxPyEndAllowThreads(__tstate);
7905 if (PyErr_Occurred()) SWIG_fail;
7906 }
7907 resultobj = SWIG_Py_Void();
7908 return resultobj;
7909 fail:
7910 return NULL;
7911 }
7912
7913
7914 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7915 PyObject *obj;
7916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7917 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7918 return SWIG_Py_Void();
7919 }
7920
7921 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7922 return SWIG_Python_InitShadowInstance(args);
7923 }
7924
7925 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7926 PyObject *resultobj = 0;
7927 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 PyObject *swig_obj[1] ;
7931
7932 if (!args) SWIG_fail;
7933 swig_obj[0] = args;
7934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7935 if (!SWIG_IsOK(res1)) {
7936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7937 }
7938 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7939 {
7940 PyThreadState* __tstate = wxPyBeginAllowThreads();
7941 delete arg1;
7942
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 resultobj = SWIG_Py_Void();
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7954 PyObject *resultobj = 0;
7955 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7956 PyObject *arg2 = (PyObject *) 0 ;
7957 void *argp1 = 0 ;
7958 int res1 = 0 ;
7959 PyObject * obj0 = 0 ;
7960 PyObject * obj1 = 0 ;
7961 char * kwnames[] = {
7962 (char *) "self",(char *) "_self", NULL
7963 };
7964
7965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7967 if (!SWIG_IsOK(res1)) {
7968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7969 }
7970 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7971 arg2 = obj1;
7972 {
7973 PyThreadState* __tstate = wxPyBeginAllowThreads();
7974 wxGridTableBase__setOORInfo(arg1,arg2);
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 resultobj = SWIG_Py_Void();
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj = 0;
7987 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7988 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7989 void *argp1 = 0 ;
7990 int res1 = 0 ;
7991 void *argp2 = 0 ;
7992 int res2 = 0 ;
7993 PyObject * obj0 = 0 ;
7994 PyObject * obj1 = 0 ;
7995 char * kwnames[] = {
7996 (char *) "self",(char *) "attrProvider", NULL
7997 };
7998
7999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
8000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8001 if (!SWIG_IsOK(res1)) {
8002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8003 }
8004 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
8006 if (!SWIG_IsOK(res2)) {
8007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
8008 }
8009 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
8010 {
8011 PyThreadState* __tstate = wxPyBeginAllowThreads();
8012 (arg1)->SetAttrProvider(arg2);
8013 wxPyEndAllowThreads(__tstate);
8014 if (PyErr_Occurred()) SWIG_fail;
8015 }
8016 resultobj = SWIG_Py_Void();
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8026 wxGridCellAttrProvider *result = 0 ;
8027 void *argp1 = 0 ;
8028 int res1 = 0 ;
8029 PyObject *swig_obj[1] ;
8030
8031 if (!args) SWIG_fail;
8032 swig_obj[0] = args;
8033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8034 if (!SWIG_IsOK(res1)) {
8035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8036 }
8037 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8038 {
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 {
8045 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
8046 }
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8054 PyObject *resultobj = 0;
8055 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8056 wxGrid *arg2 = (wxGrid *) 0 ;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 void *argp2 = 0 ;
8060 int res2 = 0 ;
8061 PyObject * obj0 = 0 ;
8062 PyObject * obj1 = 0 ;
8063 char * kwnames[] = {
8064 (char *) "self",(char *) "grid", NULL
8065 };
8066
8067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
8068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8069 if (!SWIG_IsOK(res1)) {
8070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8071 }
8072 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
8074 if (!SWIG_IsOK(res2)) {
8075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
8076 }
8077 arg2 = reinterpret_cast< wxGrid * >(argp2);
8078 {
8079 PyThreadState* __tstate = wxPyBeginAllowThreads();
8080 (arg1)->SetView(arg2);
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 resultobj = SWIG_Py_Void();
8085 return resultobj;
8086 fail:
8087 return NULL;
8088 }
8089
8090
8091 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8092 PyObject *resultobj = 0;
8093 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8094 wxGrid *result = 0 ;
8095 void *argp1 = 0 ;
8096 int res1 = 0 ;
8097 PyObject *swig_obj[1] ;
8098
8099 if (!args) SWIG_fail;
8100 swig_obj[0] = args;
8101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8102 if (!SWIG_IsOK(res1)) {
8103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8104 }
8105 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 {
8113 resultobj = wxPyMake_wxObject(result, (bool)0);
8114 }
8115 return resultobj;
8116 fail:
8117 return NULL;
8118 }
8119
8120
8121 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8122 PyObject *resultobj = 0;
8123 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8124 int result;
8125 void *argp1 = 0 ;
8126 int res1 = 0 ;
8127 PyObject *swig_obj[1] ;
8128
8129 if (!args) SWIG_fail;
8130 swig_obj[0] = args;
8131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8132 if (!SWIG_IsOK(res1)) {
8133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8134 }
8135 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 result = (int)(arg1)->GetNumberRows();
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 resultobj = SWIG_From_int(static_cast< int >(result));
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 PyObject *resultobj = 0;
8151 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8152 int result;
8153 void *argp1 = 0 ;
8154 int res1 = 0 ;
8155 PyObject *swig_obj[1] ;
8156
8157 if (!args) SWIG_fail;
8158 swig_obj[0] = args;
8159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8160 if (!SWIG_IsOK(res1)) {
8161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8162 }
8163 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8164 {
8165 PyThreadState* __tstate = wxPyBeginAllowThreads();
8166 result = (int)(arg1)->GetNumberCols();
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 resultobj = SWIG_From_int(static_cast< int >(result));
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8178 PyObject *resultobj = 0;
8179 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8180 int arg2 ;
8181 int arg3 ;
8182 bool result;
8183 void *argp1 = 0 ;
8184 int res1 = 0 ;
8185 int val2 ;
8186 int ecode2 = 0 ;
8187 int val3 ;
8188 int ecode3 = 0 ;
8189 PyObject * obj0 = 0 ;
8190 PyObject * obj1 = 0 ;
8191 PyObject * obj2 = 0 ;
8192 char * kwnames[] = {
8193 (char *) "self",(char *) "row",(char *) "col", NULL
8194 };
8195
8196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8198 if (!SWIG_IsOK(res1)) {
8199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8200 }
8201 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8202 ecode2 = SWIG_AsVal_int(obj1, &val2);
8203 if (!SWIG_IsOK(ecode2)) {
8204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8205 }
8206 arg2 = static_cast< int >(val2);
8207 ecode3 = SWIG_AsVal_int(obj2, &val3);
8208 if (!SWIG_IsOK(ecode3)) {
8209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8210 }
8211 arg3 = static_cast< int >(val3);
8212 {
8213 PyThreadState* __tstate = wxPyBeginAllowThreads();
8214 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8215 wxPyEndAllowThreads(__tstate);
8216 if (PyErr_Occurred()) SWIG_fail;
8217 }
8218 {
8219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8220 }
8221 return resultobj;
8222 fail:
8223 return NULL;
8224 }
8225
8226
8227 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8228 PyObject *resultobj = 0;
8229 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8230 int arg2 ;
8231 int arg3 ;
8232 wxString result;
8233 void *argp1 = 0 ;
8234 int res1 = 0 ;
8235 int val2 ;
8236 int ecode2 = 0 ;
8237 int val3 ;
8238 int ecode3 = 0 ;
8239 PyObject * obj0 = 0 ;
8240 PyObject * obj1 = 0 ;
8241 PyObject * obj2 = 0 ;
8242 char * kwnames[] = {
8243 (char *) "self",(char *) "row",(char *) "col", NULL
8244 };
8245
8246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8248 if (!SWIG_IsOK(res1)) {
8249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8250 }
8251 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8252 ecode2 = SWIG_AsVal_int(obj1, &val2);
8253 if (!SWIG_IsOK(ecode2)) {
8254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8255 }
8256 arg2 = static_cast< int >(val2);
8257 ecode3 = SWIG_AsVal_int(obj2, &val3);
8258 if (!SWIG_IsOK(ecode3)) {
8259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8260 }
8261 arg3 = static_cast< int >(val3);
8262 {
8263 PyThreadState* __tstate = wxPyBeginAllowThreads();
8264 result = (arg1)->GetValue(arg2,arg3);
8265 wxPyEndAllowThreads(__tstate);
8266 if (PyErr_Occurred()) SWIG_fail;
8267 }
8268 {
8269 #if wxUSE_UNICODE
8270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8271 #else
8272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8273 #endif
8274 }
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj = 0;
8283 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8284 int arg2 ;
8285 int arg3 ;
8286 wxString *arg4 = 0 ;
8287 void *argp1 = 0 ;
8288 int res1 = 0 ;
8289 int val2 ;
8290 int ecode2 = 0 ;
8291 int val3 ;
8292 int ecode3 = 0 ;
8293 bool temp4 = false ;
8294 PyObject * obj0 = 0 ;
8295 PyObject * obj1 = 0 ;
8296 PyObject * obj2 = 0 ;
8297 PyObject * obj3 = 0 ;
8298 char * kwnames[] = {
8299 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8300 };
8301
8302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8304 if (!SWIG_IsOK(res1)) {
8305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8306 }
8307 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8308 ecode2 = SWIG_AsVal_int(obj1, &val2);
8309 if (!SWIG_IsOK(ecode2)) {
8310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8311 }
8312 arg2 = static_cast< int >(val2);
8313 ecode3 = SWIG_AsVal_int(obj2, &val3);
8314 if (!SWIG_IsOK(ecode3)) {
8315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8316 }
8317 arg3 = static_cast< int >(val3);
8318 {
8319 arg4 = wxString_in_helper(obj3);
8320 if (arg4 == NULL) SWIG_fail;
8321 temp4 = true;
8322 }
8323 {
8324 PyThreadState* __tstate = wxPyBeginAllowThreads();
8325 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8326 wxPyEndAllowThreads(__tstate);
8327 if (PyErr_Occurred()) SWIG_fail;
8328 }
8329 resultobj = SWIG_Py_Void();
8330 {
8331 if (temp4)
8332 delete arg4;
8333 }
8334 return resultobj;
8335 fail:
8336 {
8337 if (temp4)
8338 delete arg4;
8339 }
8340 return NULL;
8341 }
8342
8343
8344 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj = 0;
8346 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8347 int arg2 ;
8348 int arg3 ;
8349 wxString result;
8350 void *argp1 = 0 ;
8351 int res1 = 0 ;
8352 int val2 ;
8353 int ecode2 = 0 ;
8354 int val3 ;
8355 int ecode3 = 0 ;
8356 PyObject * obj0 = 0 ;
8357 PyObject * obj1 = 0 ;
8358 PyObject * obj2 = 0 ;
8359 char * kwnames[] = {
8360 (char *) "self",(char *) "row",(char *) "col", NULL
8361 };
8362
8363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8365 if (!SWIG_IsOK(res1)) {
8366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8367 }
8368 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8369 ecode2 = SWIG_AsVal_int(obj1, &val2);
8370 if (!SWIG_IsOK(ecode2)) {
8371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8372 }
8373 arg2 = static_cast< int >(val2);
8374 ecode3 = SWIG_AsVal_int(obj2, &val3);
8375 if (!SWIG_IsOK(ecode3)) {
8376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8377 }
8378 arg3 = static_cast< int >(val3);
8379 {
8380 PyThreadState* __tstate = wxPyBeginAllowThreads();
8381 result = (arg1)->GetTypeName(arg2,arg3);
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 {
8386 #if wxUSE_UNICODE
8387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8388 #else
8389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8390 #endif
8391 }
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8401 int arg2 ;
8402 int arg3 ;
8403 wxString *arg4 = 0 ;
8404 bool result;
8405 void *argp1 = 0 ;
8406 int res1 = 0 ;
8407 int val2 ;
8408 int ecode2 = 0 ;
8409 int val3 ;
8410 int ecode3 = 0 ;
8411 bool temp4 = false ;
8412 PyObject * obj0 = 0 ;
8413 PyObject * obj1 = 0 ;
8414 PyObject * obj2 = 0 ;
8415 PyObject * obj3 = 0 ;
8416 char * kwnames[] = {
8417 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8418 };
8419
8420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8422 if (!SWIG_IsOK(res1)) {
8423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8424 }
8425 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8426 ecode2 = SWIG_AsVal_int(obj1, &val2);
8427 if (!SWIG_IsOK(ecode2)) {
8428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8429 }
8430 arg2 = static_cast< int >(val2);
8431 ecode3 = SWIG_AsVal_int(obj2, &val3);
8432 if (!SWIG_IsOK(ecode3)) {
8433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8434 }
8435 arg3 = static_cast< int >(val3);
8436 {
8437 arg4 = wxString_in_helper(obj3);
8438 if (arg4 == NULL) SWIG_fail;
8439 temp4 = true;
8440 }
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 {
8448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8449 }
8450 {
8451 if (temp4)
8452 delete arg4;
8453 }
8454 return resultobj;
8455 fail:
8456 {
8457 if (temp4)
8458 delete arg4;
8459 }
8460 return NULL;
8461 }
8462
8463
8464 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8465 PyObject *resultobj = 0;
8466 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8467 int arg2 ;
8468 int arg3 ;
8469 wxString *arg4 = 0 ;
8470 bool result;
8471 void *argp1 = 0 ;
8472 int res1 = 0 ;
8473 int val2 ;
8474 int ecode2 = 0 ;
8475 int val3 ;
8476 int ecode3 = 0 ;
8477 bool temp4 = false ;
8478 PyObject * obj0 = 0 ;
8479 PyObject * obj1 = 0 ;
8480 PyObject * obj2 = 0 ;
8481 PyObject * obj3 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8490 }
8491 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8492 ecode2 = SWIG_AsVal_int(obj1, &val2);
8493 if (!SWIG_IsOK(ecode2)) {
8494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8495 }
8496 arg2 = static_cast< int >(val2);
8497 ecode3 = SWIG_AsVal_int(obj2, &val3);
8498 if (!SWIG_IsOK(ecode3)) {
8499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8500 }
8501 arg3 = static_cast< int >(val3);
8502 {
8503 arg4 = wxString_in_helper(obj3);
8504 if (arg4 == NULL) SWIG_fail;
8505 temp4 = true;
8506 }
8507 {
8508 PyThreadState* __tstate = wxPyBeginAllowThreads();
8509 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8510 wxPyEndAllowThreads(__tstate);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 {
8514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8515 }
8516 {
8517 if (temp4)
8518 delete arg4;
8519 }
8520 return resultobj;
8521 fail:
8522 {
8523 if (temp4)
8524 delete arg4;
8525 }
8526 return NULL;
8527 }
8528
8529
8530 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8531 PyObject *resultobj = 0;
8532 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8533 int arg2 ;
8534 int arg3 ;
8535 long result;
8536 void *argp1 = 0 ;
8537 int res1 = 0 ;
8538 int val2 ;
8539 int ecode2 = 0 ;
8540 int val3 ;
8541 int ecode3 = 0 ;
8542 PyObject * obj0 = 0 ;
8543 PyObject * obj1 = 0 ;
8544 PyObject * obj2 = 0 ;
8545 char * kwnames[] = {
8546 (char *) "self",(char *) "row",(char *) "col", NULL
8547 };
8548
8549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8551 if (!SWIG_IsOK(res1)) {
8552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8553 }
8554 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8555 ecode2 = SWIG_AsVal_int(obj1, &val2);
8556 if (!SWIG_IsOK(ecode2)) {
8557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8558 }
8559 arg2 = static_cast< int >(val2);
8560 ecode3 = SWIG_AsVal_int(obj2, &val3);
8561 if (!SWIG_IsOK(ecode3)) {
8562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8563 }
8564 arg3 = static_cast< int >(val3);
8565 {
8566 PyThreadState* __tstate = wxPyBeginAllowThreads();
8567 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8568 wxPyEndAllowThreads(__tstate);
8569 if (PyErr_Occurred()) SWIG_fail;
8570 }
8571 resultobj = SWIG_From_long(static_cast< long >(result));
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj = 0;
8580 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8581 int arg2 ;
8582 int arg3 ;
8583 double result;
8584 void *argp1 = 0 ;
8585 int res1 = 0 ;
8586 int val2 ;
8587 int ecode2 = 0 ;
8588 int val3 ;
8589 int ecode3 = 0 ;
8590 PyObject * obj0 = 0 ;
8591 PyObject * obj1 = 0 ;
8592 PyObject * obj2 = 0 ;
8593 char * kwnames[] = {
8594 (char *) "self",(char *) "row",(char *) "col", NULL
8595 };
8596
8597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8599 if (!SWIG_IsOK(res1)) {
8600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8601 }
8602 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8603 ecode2 = SWIG_AsVal_int(obj1, &val2);
8604 if (!SWIG_IsOK(ecode2)) {
8605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8606 }
8607 arg2 = static_cast< int >(val2);
8608 ecode3 = SWIG_AsVal_int(obj2, &val3);
8609 if (!SWIG_IsOK(ecode3)) {
8610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8611 }
8612 arg3 = static_cast< int >(val3);
8613 {
8614 PyThreadState* __tstate = wxPyBeginAllowThreads();
8615 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8616 wxPyEndAllowThreads(__tstate);
8617 if (PyErr_Occurred()) SWIG_fail;
8618 }
8619 resultobj = SWIG_From_double(static_cast< double >(result));
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj = 0;
8628 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8629 int arg2 ;
8630 int arg3 ;
8631 bool result;
8632 void *argp1 = 0 ;
8633 int res1 = 0 ;
8634 int val2 ;
8635 int ecode2 = 0 ;
8636 int val3 ;
8637 int ecode3 = 0 ;
8638 PyObject * obj0 = 0 ;
8639 PyObject * obj1 = 0 ;
8640 PyObject * obj2 = 0 ;
8641 char * kwnames[] = {
8642 (char *) "self",(char *) "row",(char *) "col", NULL
8643 };
8644
8645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8647 if (!SWIG_IsOK(res1)) {
8648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8649 }
8650 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8651 ecode2 = SWIG_AsVal_int(obj1, &val2);
8652 if (!SWIG_IsOK(ecode2)) {
8653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8654 }
8655 arg2 = static_cast< int >(val2);
8656 ecode3 = SWIG_AsVal_int(obj2, &val3);
8657 if (!SWIG_IsOK(ecode3)) {
8658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8659 }
8660 arg3 = static_cast< int >(val3);
8661 {
8662 PyThreadState* __tstate = wxPyBeginAllowThreads();
8663 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8664 wxPyEndAllowThreads(__tstate);
8665 if (PyErr_Occurred()) SWIG_fail;
8666 }
8667 {
8668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8669 }
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
8676 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8677 PyObject *resultobj = 0;
8678 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8679 int arg2 ;
8680 int arg3 ;
8681 long arg4 ;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 int val2 ;
8685 int ecode2 = 0 ;
8686 int val3 ;
8687 int ecode3 = 0 ;
8688 long val4 ;
8689 int ecode4 = 0 ;
8690 PyObject * obj0 = 0 ;
8691 PyObject * obj1 = 0 ;
8692 PyObject * obj2 = 0 ;
8693 PyObject * obj3 = 0 ;
8694 char * kwnames[] = {
8695 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8696 };
8697
8698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8700 if (!SWIG_IsOK(res1)) {
8701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8702 }
8703 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8704 ecode2 = SWIG_AsVal_int(obj1, &val2);
8705 if (!SWIG_IsOK(ecode2)) {
8706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8707 }
8708 arg2 = static_cast< int >(val2);
8709 ecode3 = SWIG_AsVal_int(obj2, &val3);
8710 if (!SWIG_IsOK(ecode3)) {
8711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8712 }
8713 arg3 = static_cast< int >(val3);
8714 ecode4 = SWIG_AsVal_long(obj3, &val4);
8715 if (!SWIG_IsOK(ecode4)) {
8716 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8717 }
8718 arg4 = static_cast< long >(val4);
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8722 wxPyEndAllowThreads(__tstate);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 resultobj = SWIG_Py_Void();
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj = 0;
8734 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8735 int arg2 ;
8736 int arg3 ;
8737 double arg4 ;
8738 void *argp1 = 0 ;
8739 int res1 = 0 ;
8740 int val2 ;
8741 int ecode2 = 0 ;
8742 int val3 ;
8743 int ecode3 = 0 ;
8744 double val4 ;
8745 int ecode4 = 0 ;
8746 PyObject * obj0 = 0 ;
8747 PyObject * obj1 = 0 ;
8748 PyObject * obj2 = 0 ;
8749 PyObject * obj3 = 0 ;
8750 char * kwnames[] = {
8751 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8752 };
8753
8754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8756 if (!SWIG_IsOK(res1)) {
8757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8758 }
8759 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8760 ecode2 = SWIG_AsVal_int(obj1, &val2);
8761 if (!SWIG_IsOK(ecode2)) {
8762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8763 }
8764 arg2 = static_cast< int >(val2);
8765 ecode3 = SWIG_AsVal_int(obj2, &val3);
8766 if (!SWIG_IsOK(ecode3)) {
8767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8768 }
8769 arg3 = static_cast< int >(val3);
8770 ecode4 = SWIG_AsVal_double(obj3, &val4);
8771 if (!SWIG_IsOK(ecode4)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8773 }
8774 arg4 = static_cast< double >(val4);
8775 {
8776 PyThreadState* __tstate = wxPyBeginAllowThreads();
8777 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8778 wxPyEndAllowThreads(__tstate);
8779 if (PyErr_Occurred()) SWIG_fail;
8780 }
8781 resultobj = SWIG_Py_Void();
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj = 0;
8790 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8791 int arg2 ;
8792 int arg3 ;
8793 bool arg4 ;
8794 void *argp1 = 0 ;
8795 int res1 = 0 ;
8796 int val2 ;
8797 int ecode2 = 0 ;
8798 int val3 ;
8799 int ecode3 = 0 ;
8800 bool val4 ;
8801 int ecode4 = 0 ;
8802 PyObject * obj0 = 0 ;
8803 PyObject * obj1 = 0 ;
8804 PyObject * obj2 = 0 ;
8805 PyObject * obj3 = 0 ;
8806 char * kwnames[] = {
8807 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8808 };
8809
8810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8814 }
8815 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8816 ecode2 = SWIG_AsVal_int(obj1, &val2);
8817 if (!SWIG_IsOK(ecode2)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8819 }
8820 arg2 = static_cast< int >(val2);
8821 ecode3 = SWIG_AsVal_int(obj2, &val3);
8822 if (!SWIG_IsOK(ecode3)) {
8823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8824 }
8825 arg3 = static_cast< int >(val3);
8826 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8827 if (!SWIG_IsOK(ecode4)) {
8828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8829 }
8830 arg4 = static_cast< bool >(val4);
8831 {
8832 PyThreadState* __tstate = wxPyBeginAllowThreads();
8833 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 resultobj = SWIG_Py_Void();
8838 return resultobj;
8839 fail:
8840 return NULL;
8841 }
8842
8843
8844 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8845 PyObject *resultobj = 0;
8846 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8847 void *argp1 = 0 ;
8848 int res1 = 0 ;
8849 PyObject *swig_obj[1] ;
8850
8851 if (!args) SWIG_fail;
8852 swig_obj[0] = args;
8853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8854 if (!SWIG_IsOK(res1)) {
8855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8856 }
8857 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8858 {
8859 PyThreadState* __tstate = wxPyBeginAllowThreads();
8860 (arg1)->Clear();
8861 wxPyEndAllowThreads(__tstate);
8862 if (PyErr_Occurred()) SWIG_fail;
8863 }
8864 resultobj = SWIG_Py_Void();
8865 return resultobj;
8866 fail:
8867 return NULL;
8868 }
8869
8870
8871 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8872 PyObject *resultobj = 0;
8873 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8874 size_t arg2 = (size_t) 0 ;
8875 size_t arg3 = (size_t) 1 ;
8876 bool result;
8877 void *argp1 = 0 ;
8878 int res1 = 0 ;
8879 size_t val2 ;
8880 int ecode2 = 0 ;
8881 size_t val3 ;
8882 int ecode3 = 0 ;
8883 PyObject * obj0 = 0 ;
8884 PyObject * obj1 = 0 ;
8885 PyObject * obj2 = 0 ;
8886 char * kwnames[] = {
8887 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8888 };
8889
8890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8892 if (!SWIG_IsOK(res1)) {
8893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8894 }
8895 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8896 if (obj1) {
8897 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8898 if (!SWIG_IsOK(ecode2)) {
8899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8900 }
8901 arg2 = static_cast< size_t >(val2);
8902 }
8903 if (obj2) {
8904 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8905 if (!SWIG_IsOK(ecode3)) {
8906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8907 }
8908 arg3 = static_cast< size_t >(val3);
8909 }
8910 {
8911 PyThreadState* __tstate = wxPyBeginAllowThreads();
8912 result = (bool)(arg1)->InsertRows(arg2,arg3);
8913 wxPyEndAllowThreads(__tstate);
8914 if (PyErr_Occurred()) SWIG_fail;
8915 }
8916 {
8917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8918 }
8919 return resultobj;
8920 fail:
8921 return NULL;
8922 }
8923
8924
8925 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8926 PyObject *resultobj = 0;
8927 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8928 size_t arg2 = (size_t) 1 ;
8929 bool result;
8930 void *argp1 = 0 ;
8931 int res1 = 0 ;
8932 size_t val2 ;
8933 int ecode2 = 0 ;
8934 PyObject * obj0 = 0 ;
8935 PyObject * obj1 = 0 ;
8936 char * kwnames[] = {
8937 (char *) "self",(char *) "numRows", NULL
8938 };
8939
8940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8942 if (!SWIG_IsOK(res1)) {
8943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8944 }
8945 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8946 if (obj1) {
8947 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8948 if (!SWIG_IsOK(ecode2)) {
8949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8950 }
8951 arg2 = static_cast< size_t >(val2);
8952 }
8953 {
8954 PyThreadState* __tstate = wxPyBeginAllowThreads();
8955 result = (bool)(arg1)->AppendRows(arg2);
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 {
8960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8961 }
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj = 0;
8970 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8971 size_t arg2 = (size_t) 0 ;
8972 size_t arg3 = (size_t) 1 ;
8973 bool result;
8974 void *argp1 = 0 ;
8975 int res1 = 0 ;
8976 size_t val2 ;
8977 int ecode2 = 0 ;
8978 size_t val3 ;
8979 int ecode3 = 0 ;
8980 PyObject * obj0 = 0 ;
8981 PyObject * obj1 = 0 ;
8982 PyObject * obj2 = 0 ;
8983 char * kwnames[] = {
8984 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8985 };
8986
8987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8989 if (!SWIG_IsOK(res1)) {
8990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8991 }
8992 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8993 if (obj1) {
8994 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8995 if (!SWIG_IsOK(ecode2)) {
8996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8997 }
8998 arg2 = static_cast< size_t >(val2);
8999 }
9000 if (obj2) {
9001 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9002 if (!SWIG_IsOK(ecode3)) {
9003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
9004 }
9005 arg3 = static_cast< size_t >(val3);
9006 }
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 result = (bool)(arg1)->DeleteRows(arg2,arg3);
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 {
9014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9015 }
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9023 PyObject *resultobj = 0;
9024 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9025 size_t arg2 = (size_t) 0 ;
9026 size_t arg3 = (size_t) 1 ;
9027 bool result;
9028 void *argp1 = 0 ;
9029 int res1 = 0 ;
9030 size_t val2 ;
9031 int ecode2 = 0 ;
9032 size_t val3 ;
9033 int ecode3 = 0 ;
9034 PyObject * obj0 = 0 ;
9035 PyObject * obj1 = 0 ;
9036 PyObject * obj2 = 0 ;
9037 char * kwnames[] = {
9038 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9039 };
9040
9041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9043 if (!SWIG_IsOK(res1)) {
9044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9045 }
9046 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9047 if (obj1) {
9048 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9049 if (!SWIG_IsOK(ecode2)) {
9050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
9051 }
9052 arg2 = static_cast< size_t >(val2);
9053 }
9054 if (obj2) {
9055 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9056 if (!SWIG_IsOK(ecode3)) {
9057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
9058 }
9059 arg3 = static_cast< size_t >(val3);
9060 }
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = (bool)(arg1)->InsertCols(arg2,arg3);
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 {
9068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9069 }
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9077 PyObject *resultobj = 0;
9078 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9079 size_t arg2 = (size_t) 1 ;
9080 bool result;
9081 void *argp1 = 0 ;
9082 int res1 = 0 ;
9083 size_t val2 ;
9084 int ecode2 = 0 ;
9085 PyObject * obj0 = 0 ;
9086 PyObject * obj1 = 0 ;
9087 char * kwnames[] = {
9088 (char *) "self",(char *) "numCols", NULL
9089 };
9090
9091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
9092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9093 if (!SWIG_IsOK(res1)) {
9094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9095 }
9096 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9097 if (obj1) {
9098 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9099 if (!SWIG_IsOK(ecode2)) {
9100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
9101 }
9102 arg2 = static_cast< size_t >(val2);
9103 }
9104 {
9105 PyThreadState* __tstate = wxPyBeginAllowThreads();
9106 result = (bool)(arg1)->AppendCols(arg2);
9107 wxPyEndAllowThreads(__tstate);
9108 if (PyErr_Occurred()) SWIG_fail;
9109 }
9110 {
9111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9112 }
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj = 0;
9121 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9122 size_t arg2 = (size_t) 0 ;
9123 size_t arg3 = (size_t) 1 ;
9124 bool result;
9125 void *argp1 = 0 ;
9126 int res1 = 0 ;
9127 size_t val2 ;
9128 int ecode2 = 0 ;
9129 size_t val3 ;
9130 int ecode3 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 PyObject * obj1 = 0 ;
9133 PyObject * obj2 = 0 ;
9134 char * kwnames[] = {
9135 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9136 };
9137
9138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9140 if (!SWIG_IsOK(res1)) {
9141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9142 }
9143 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9144 if (obj1) {
9145 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9146 if (!SWIG_IsOK(ecode2)) {
9147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9148 }
9149 arg2 = static_cast< size_t >(val2);
9150 }
9151 if (obj2) {
9152 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9153 if (!SWIG_IsOK(ecode3)) {
9154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9155 }
9156 arg3 = static_cast< size_t >(val3);
9157 }
9158 {
9159 PyThreadState* __tstate = wxPyBeginAllowThreads();
9160 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9161 wxPyEndAllowThreads(__tstate);
9162 if (PyErr_Occurred()) SWIG_fail;
9163 }
9164 {
9165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9166 }
9167 return resultobj;
9168 fail:
9169 return NULL;
9170 }
9171
9172
9173 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9174 PyObject *resultobj = 0;
9175 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9176 int arg2 ;
9177 wxString result;
9178 void *argp1 = 0 ;
9179 int res1 = 0 ;
9180 int val2 ;
9181 int ecode2 = 0 ;
9182 PyObject * obj0 = 0 ;
9183 PyObject * obj1 = 0 ;
9184 char * kwnames[] = {
9185 (char *) "self",(char *) "row", NULL
9186 };
9187
9188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9190 if (!SWIG_IsOK(res1)) {
9191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9192 }
9193 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9194 ecode2 = SWIG_AsVal_int(obj1, &val2);
9195 if (!SWIG_IsOK(ecode2)) {
9196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9197 }
9198 arg2 = static_cast< int >(val2);
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 result = (arg1)->GetRowLabelValue(arg2);
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 {
9206 #if wxUSE_UNICODE
9207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9208 #else
9209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9210 #endif
9211 }
9212 return resultobj;
9213 fail:
9214 return NULL;
9215 }
9216
9217
9218 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9219 PyObject *resultobj = 0;
9220 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9221 int arg2 ;
9222 wxString result;
9223 void *argp1 = 0 ;
9224 int res1 = 0 ;
9225 int val2 ;
9226 int ecode2 = 0 ;
9227 PyObject * obj0 = 0 ;
9228 PyObject * obj1 = 0 ;
9229 char * kwnames[] = {
9230 (char *) "self",(char *) "col", NULL
9231 };
9232
9233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9235 if (!SWIG_IsOK(res1)) {
9236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9237 }
9238 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9239 ecode2 = SWIG_AsVal_int(obj1, &val2);
9240 if (!SWIG_IsOK(ecode2)) {
9241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9242 }
9243 arg2 = static_cast< int >(val2);
9244 {
9245 PyThreadState* __tstate = wxPyBeginAllowThreads();
9246 result = (arg1)->GetColLabelValue(arg2);
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 {
9251 #if wxUSE_UNICODE
9252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9253 #else
9254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9255 #endif
9256 }
9257 return resultobj;
9258 fail:
9259 return NULL;
9260 }
9261
9262
9263 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9264 PyObject *resultobj = 0;
9265 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9266 int arg2 ;
9267 wxString *arg3 = 0 ;
9268 void *argp1 = 0 ;
9269 int res1 = 0 ;
9270 int val2 ;
9271 int ecode2 = 0 ;
9272 bool temp3 = false ;
9273 PyObject * obj0 = 0 ;
9274 PyObject * obj1 = 0 ;
9275 PyObject * obj2 = 0 ;
9276 char * kwnames[] = {
9277 (char *) "self",(char *) "row",(char *) "value", NULL
9278 };
9279
9280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9282 if (!SWIG_IsOK(res1)) {
9283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9284 }
9285 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9286 ecode2 = SWIG_AsVal_int(obj1, &val2);
9287 if (!SWIG_IsOK(ecode2)) {
9288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9289 }
9290 arg2 = static_cast< int >(val2);
9291 {
9292 arg3 = wxString_in_helper(obj2);
9293 if (arg3 == NULL) SWIG_fail;
9294 temp3 = true;
9295 }
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9299 wxPyEndAllowThreads(__tstate);
9300 if (PyErr_Occurred()) SWIG_fail;
9301 }
9302 resultobj = SWIG_Py_Void();
9303 {
9304 if (temp3)
9305 delete arg3;
9306 }
9307 return resultobj;
9308 fail:
9309 {
9310 if (temp3)
9311 delete arg3;
9312 }
9313 return NULL;
9314 }
9315
9316
9317 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9318 PyObject *resultobj = 0;
9319 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9320 int arg2 ;
9321 wxString *arg3 = 0 ;
9322 void *argp1 = 0 ;
9323 int res1 = 0 ;
9324 int val2 ;
9325 int ecode2 = 0 ;
9326 bool temp3 = false ;
9327 PyObject * obj0 = 0 ;
9328 PyObject * obj1 = 0 ;
9329 PyObject * obj2 = 0 ;
9330 char * kwnames[] = {
9331 (char *) "self",(char *) "col",(char *) "value", NULL
9332 };
9333
9334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9336 if (!SWIG_IsOK(res1)) {
9337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9338 }
9339 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9340 ecode2 = SWIG_AsVal_int(obj1, &val2);
9341 if (!SWIG_IsOK(ecode2)) {
9342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9343 }
9344 arg2 = static_cast< int >(val2);
9345 {
9346 arg3 = wxString_in_helper(obj2);
9347 if (arg3 == NULL) SWIG_fail;
9348 temp3 = true;
9349 }
9350 {
9351 PyThreadState* __tstate = wxPyBeginAllowThreads();
9352 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9353 wxPyEndAllowThreads(__tstate);
9354 if (PyErr_Occurred()) SWIG_fail;
9355 }
9356 resultobj = SWIG_Py_Void();
9357 {
9358 if (temp3)
9359 delete arg3;
9360 }
9361 return resultobj;
9362 fail:
9363 {
9364 if (temp3)
9365 delete arg3;
9366 }
9367 return NULL;
9368 }
9369
9370
9371 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9372 PyObject *resultobj = 0;
9373 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9374 bool result;
9375 void *argp1 = 0 ;
9376 int res1 = 0 ;
9377 PyObject *swig_obj[1] ;
9378
9379 if (!args) SWIG_fail;
9380 swig_obj[0] = args;
9381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9384 }
9385 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9386 {
9387 PyThreadState* __tstate = wxPyBeginAllowThreads();
9388 result = (bool)(arg1)->CanHaveAttributes();
9389 wxPyEndAllowThreads(__tstate);
9390 if (PyErr_Occurred()) SWIG_fail;
9391 }
9392 {
9393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9394 }
9395 return resultobj;
9396 fail:
9397 return NULL;
9398 }
9399
9400
9401 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9402 PyObject *resultobj = 0;
9403 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9404 int arg2 ;
9405 int arg3 ;
9406 wxGridCellAttr::wxAttrKind arg4 ;
9407 wxGridCellAttr *result = 0 ;
9408 void *argp1 = 0 ;
9409 int res1 = 0 ;
9410 int val2 ;
9411 int ecode2 = 0 ;
9412 int val3 ;
9413 int ecode3 = 0 ;
9414 int val4 ;
9415 int ecode4 = 0 ;
9416 PyObject * obj0 = 0 ;
9417 PyObject * obj1 = 0 ;
9418 PyObject * obj2 = 0 ;
9419 PyObject * obj3 = 0 ;
9420 char * kwnames[] = {
9421 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9422 };
9423
9424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9428 }
9429 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9430 ecode2 = SWIG_AsVal_int(obj1, &val2);
9431 if (!SWIG_IsOK(ecode2)) {
9432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9433 }
9434 arg2 = static_cast< int >(val2);
9435 ecode3 = SWIG_AsVal_int(obj2, &val3);
9436 if (!SWIG_IsOK(ecode3)) {
9437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9438 }
9439 arg3 = static_cast< int >(val3);
9440 ecode4 = SWIG_AsVal_int(obj3, &val4);
9441 if (!SWIG_IsOK(ecode4)) {
9442 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9443 }
9444 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9445 {
9446 PyThreadState* __tstate = wxPyBeginAllowThreads();
9447 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9448 wxPyEndAllowThreads(__tstate);
9449 if (PyErr_Occurred()) SWIG_fail;
9450 }
9451 {
9452 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9453 }
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj = 0;
9462 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9463 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9464 int arg3 ;
9465 int arg4 ;
9466 void *argp1 = 0 ;
9467 int res1 = 0 ;
9468 void *argp2 = 0 ;
9469 int res2 = 0 ;
9470 int val3 ;
9471 int ecode3 = 0 ;
9472 int val4 ;
9473 int ecode4 = 0 ;
9474 PyObject * obj0 = 0 ;
9475 PyObject * obj1 = 0 ;
9476 PyObject * obj2 = 0 ;
9477 PyObject * obj3 = 0 ;
9478 char * kwnames[] = {
9479 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9480 };
9481
9482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9484 if (!SWIG_IsOK(res1)) {
9485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9486 }
9487 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9488 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9489 if (!SWIG_IsOK(res2)) {
9490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9491 }
9492 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9493 ecode3 = SWIG_AsVal_int(obj2, &val3);
9494 if (!SWIG_IsOK(ecode3)) {
9495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9496 }
9497 arg3 = static_cast< int >(val3);
9498 ecode4 = SWIG_AsVal_int(obj3, &val4);
9499 if (!SWIG_IsOK(ecode4)) {
9500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9501 }
9502 arg4 = static_cast< int >(val4);
9503 {
9504 PyThreadState* __tstate = wxPyBeginAllowThreads();
9505 (arg1)->SetAttr(arg2,arg3,arg4);
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_Py_Void();
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj = 0;
9518 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9519 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9520 int arg3 ;
9521 void *argp1 = 0 ;
9522 int res1 = 0 ;
9523 void *argp2 = 0 ;
9524 int res2 = 0 ;
9525 int val3 ;
9526 int ecode3 = 0 ;
9527 PyObject * obj0 = 0 ;
9528 PyObject * obj1 = 0 ;
9529 PyObject * obj2 = 0 ;
9530 char * kwnames[] = {
9531 (char *) "self",(char *) "attr",(char *) "row", NULL
9532 };
9533
9534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9536 if (!SWIG_IsOK(res1)) {
9537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9538 }
9539 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9541 if (!SWIG_IsOK(res2)) {
9542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9543 }
9544 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9545 ecode3 = SWIG_AsVal_int(obj2, &val3);
9546 if (!SWIG_IsOK(ecode3)) {
9547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9548 }
9549 arg3 = static_cast< int >(val3);
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 (arg1)->SetRowAttr(arg2,arg3);
9553 wxPyEndAllowThreads(__tstate);
9554 if (PyErr_Occurred()) SWIG_fail;
9555 }
9556 resultobj = SWIG_Py_Void();
9557 return resultobj;
9558 fail:
9559 return NULL;
9560 }
9561
9562
9563 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9564 PyObject *resultobj = 0;
9565 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9566 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9567 int arg3 ;
9568 void *argp1 = 0 ;
9569 int res1 = 0 ;
9570 void *argp2 = 0 ;
9571 int res2 = 0 ;
9572 int val3 ;
9573 int ecode3 = 0 ;
9574 PyObject * obj0 = 0 ;
9575 PyObject * obj1 = 0 ;
9576 PyObject * obj2 = 0 ;
9577 char * kwnames[] = {
9578 (char *) "self",(char *) "attr",(char *) "col", NULL
9579 };
9580
9581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9583 if (!SWIG_IsOK(res1)) {
9584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9585 }
9586 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9588 if (!SWIG_IsOK(res2)) {
9589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9590 }
9591 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9592 ecode3 = SWIG_AsVal_int(obj2, &val3);
9593 if (!SWIG_IsOK(ecode3)) {
9594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9595 }
9596 arg3 = static_cast< int >(val3);
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 (arg1)->SetColAttr(arg2,arg3);
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 resultobj = SWIG_Py_Void();
9604 return resultobj;
9605 fail:
9606 return NULL;
9607 }
9608
9609
9610 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9611 PyObject *obj;
9612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9613 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9614 return SWIG_Py_Void();
9615 }
9616
9617 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9618 PyObject *resultobj = 0;
9619 wxPyGridTableBase *result = 0 ;
9620
9621 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9622 {
9623 PyThreadState* __tstate = wxPyBeginAllowThreads();
9624 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9629 return resultobj;
9630 fail:
9631 return NULL;
9632 }
9633
9634
9635 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj = 0;
9637 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9638 PyObject *arg2 = (PyObject *) 0 ;
9639 PyObject *arg3 = (PyObject *) 0 ;
9640 void *argp1 = 0 ;
9641 int res1 = 0 ;
9642 PyObject * obj0 = 0 ;
9643 PyObject * obj1 = 0 ;
9644 PyObject * obj2 = 0 ;
9645 char * kwnames[] = {
9646 (char *) "self",(char *) "self",(char *) "_class", NULL
9647 };
9648
9649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9651 if (!SWIG_IsOK(res1)) {
9652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9653 }
9654 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9655 arg2 = obj1;
9656 arg3 = obj2;
9657 {
9658 PyThreadState* __tstate = wxPyBeginAllowThreads();
9659 (arg1)->_setCallbackInfo(arg2,arg3);
9660 wxPyEndAllowThreads(__tstate);
9661 if (PyErr_Occurred()) SWIG_fail;
9662 }
9663 resultobj = SWIG_Py_Void();
9664 return resultobj;
9665 fail:
9666 return NULL;
9667 }
9668
9669
9670 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9671 PyObject *resultobj = 0;
9672 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9673 void *argp1 = 0 ;
9674 int res1 = 0 ;
9675 PyObject *swig_obj[1] ;
9676
9677 if (!args) SWIG_fail;
9678 swig_obj[0] = args;
9679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9680 if (!SWIG_IsOK(res1)) {
9681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9682 }
9683 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9684 {
9685 PyThreadState* __tstate = wxPyBeginAllowThreads();
9686 wxPyGridTableBase_Destroy(arg1);
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_Py_Void();
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9698 PyObject *obj;
9699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9700 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9701 return SWIG_Py_Void();
9702 }
9703
9704 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9705 return SWIG_Python_InitShadowInstance(args);
9706 }
9707
9708 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9709 PyObject *resultobj = 0;
9710 int arg1 = (int) 0 ;
9711 int arg2 = (int) 0 ;
9712 wxGridStringTable *result = 0 ;
9713 int val1 ;
9714 int ecode1 = 0 ;
9715 int val2 ;
9716 int ecode2 = 0 ;
9717 PyObject * obj0 = 0 ;
9718 PyObject * obj1 = 0 ;
9719 char * kwnames[] = {
9720 (char *) "numRows",(char *) "numCols", NULL
9721 };
9722
9723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9724 if (obj0) {
9725 ecode1 = SWIG_AsVal_int(obj0, &val1);
9726 if (!SWIG_IsOK(ecode1)) {
9727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9728 }
9729 arg1 = static_cast< int >(val1);
9730 }
9731 if (obj1) {
9732 ecode2 = SWIG_AsVal_int(obj1, &val2);
9733 if (!SWIG_IsOK(ecode2)) {
9734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9735 }
9736 arg2 = static_cast< int >(val2);
9737 }
9738 {
9739 PyThreadState* __tstate = wxPyBeginAllowThreads();
9740 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752 PyObject *obj;
9753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9754 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9755 return SWIG_Py_Void();
9756 }
9757
9758 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9759 return SWIG_Python_InitShadowInstance(args);
9760 }
9761
9762 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9763 PyObject *resultobj = 0;
9764 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9765 int arg2 ;
9766 int arg3 = (int) -1 ;
9767 int arg4 = (int) -1 ;
9768 wxGridTableMessage *result = 0 ;
9769 void *argp1 = 0 ;
9770 int res1 = 0 ;
9771 int val2 ;
9772 int ecode2 = 0 ;
9773 int val3 ;
9774 int ecode3 = 0 ;
9775 int val4 ;
9776 int ecode4 = 0 ;
9777 PyObject * obj0 = 0 ;
9778 PyObject * obj1 = 0 ;
9779 PyObject * obj2 = 0 ;
9780 PyObject * obj3 = 0 ;
9781 char * kwnames[] = {
9782 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9783 };
9784
9785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9789 }
9790 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9791 ecode2 = SWIG_AsVal_int(obj1, &val2);
9792 if (!SWIG_IsOK(ecode2)) {
9793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9794 }
9795 arg2 = static_cast< int >(val2);
9796 if (obj2) {
9797 ecode3 = SWIG_AsVal_int(obj2, &val3);
9798 if (!SWIG_IsOK(ecode3)) {
9799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9800 }
9801 arg3 = static_cast< int >(val3);
9802 }
9803 if (obj3) {
9804 ecode4 = SWIG_AsVal_int(obj3, &val4);
9805 if (!SWIG_IsOK(ecode4)) {
9806 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9807 }
9808 arg4 = static_cast< int >(val4);
9809 }
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9817 return resultobj;
9818 fail:
9819 return NULL;
9820 }
9821
9822
9823 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9824 PyObject *resultobj = 0;
9825 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9826 void *argp1 = 0 ;
9827 int res1 = 0 ;
9828 PyObject *swig_obj[1] ;
9829
9830 if (!args) SWIG_fail;
9831 swig_obj[0] = args;
9832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9833 if (!SWIG_IsOK(res1)) {
9834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9835 }
9836 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9837 {
9838 PyThreadState* __tstate = wxPyBeginAllowThreads();
9839 delete arg1;
9840
9841 wxPyEndAllowThreads(__tstate);
9842 if (PyErr_Occurred()) SWIG_fail;
9843 }
9844 resultobj = SWIG_Py_Void();
9845 return resultobj;
9846 fail:
9847 return NULL;
9848 }
9849
9850
9851 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9852 PyObject *resultobj = 0;
9853 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9854 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9855 void *argp1 = 0 ;
9856 int res1 = 0 ;
9857 void *argp2 = 0 ;
9858 int res2 = 0 ;
9859 PyObject * obj0 = 0 ;
9860 PyObject * obj1 = 0 ;
9861 char * kwnames[] = {
9862 (char *) "self",(char *) "table", NULL
9863 };
9864
9865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9867 if (!SWIG_IsOK(res1)) {
9868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9869 }
9870 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9872 if (!SWIG_IsOK(res2)) {
9873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9874 }
9875 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 (arg1)->SetTableObject(arg2);
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 resultobj = SWIG_Py_Void();
9883 return resultobj;
9884 fail:
9885 return NULL;
9886 }
9887
9888
9889 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 PyObject *resultobj = 0;
9891 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9892 wxGridTableBase *result = 0 ;
9893 void *argp1 = 0 ;
9894 int res1 = 0 ;
9895 PyObject *swig_obj[1] ;
9896
9897 if (!args) SWIG_fail;
9898 swig_obj[0] = args;
9899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9900 if (!SWIG_IsOK(res1)) {
9901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9902 }
9903 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 {
9911 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9912 }
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj = 0;
9921 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9922 int arg2 ;
9923 void *argp1 = 0 ;
9924 int res1 = 0 ;
9925 int val2 ;
9926 int ecode2 = 0 ;
9927 PyObject * obj0 = 0 ;
9928 PyObject * obj1 = 0 ;
9929 char * kwnames[] = {
9930 (char *) "self",(char *) "id", NULL
9931 };
9932
9933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9935 if (!SWIG_IsOK(res1)) {
9936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9937 }
9938 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9939 ecode2 = SWIG_AsVal_int(obj1, &val2);
9940 if (!SWIG_IsOK(ecode2)) {
9941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9942 }
9943 arg2 = static_cast< int >(val2);
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 (arg1)->SetId(arg2);
9947 wxPyEndAllowThreads(__tstate);
9948 if (PyErr_Occurred()) SWIG_fail;
9949 }
9950 resultobj = SWIG_Py_Void();
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9958 PyObject *resultobj = 0;
9959 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9960 int result;
9961 void *argp1 = 0 ;
9962 int res1 = 0 ;
9963 PyObject *swig_obj[1] ;
9964
9965 if (!args) SWIG_fail;
9966 swig_obj[0] = args;
9967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9968 if (!SWIG_IsOK(res1)) {
9969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9970 }
9971 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 result = (int)(arg1)->GetId();
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_From_int(static_cast< int >(result));
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj = 0;
9987 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9988 int arg2 ;
9989 void *argp1 = 0 ;
9990 int res1 = 0 ;
9991 int val2 ;
9992 int ecode2 = 0 ;
9993 PyObject * obj0 = 0 ;
9994 PyObject * obj1 = 0 ;
9995 char * kwnames[] = {
9996 (char *) "self",(char *) "comInt1", NULL
9997 };
9998
9999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
10000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10001 if (!SWIG_IsOK(res1)) {
10002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10003 }
10004 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10005 ecode2 = SWIG_AsVal_int(obj1, &val2);
10006 if (!SWIG_IsOK(ecode2)) {
10007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
10008 }
10009 arg2 = static_cast< int >(val2);
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 (arg1)->SetCommandInt(arg2);
10013 wxPyEndAllowThreads(__tstate);
10014 if (PyErr_Occurred()) SWIG_fail;
10015 }
10016 resultobj = SWIG_Py_Void();
10017 return resultobj;
10018 fail:
10019 return NULL;
10020 }
10021
10022
10023 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10024 PyObject *resultobj = 0;
10025 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10026 int result;
10027 void *argp1 = 0 ;
10028 int res1 = 0 ;
10029 PyObject *swig_obj[1] ;
10030
10031 if (!args) SWIG_fail;
10032 swig_obj[0] = args;
10033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10034 if (!SWIG_IsOK(res1)) {
10035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10036 }
10037 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10038 {
10039 PyThreadState* __tstate = wxPyBeginAllowThreads();
10040 result = (int)(arg1)->GetCommandInt();
10041 wxPyEndAllowThreads(__tstate);
10042 if (PyErr_Occurred()) SWIG_fail;
10043 }
10044 resultobj = SWIG_From_int(static_cast< int >(result));
10045 return resultobj;
10046 fail:
10047 return NULL;
10048 }
10049
10050
10051 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10052 PyObject *resultobj = 0;
10053 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10054 int arg2 ;
10055 void *argp1 = 0 ;
10056 int res1 = 0 ;
10057 int val2 ;
10058 int ecode2 = 0 ;
10059 PyObject * obj0 = 0 ;
10060 PyObject * obj1 = 0 ;
10061 char * kwnames[] = {
10062 (char *) "self",(char *) "comInt2", NULL
10063 };
10064
10065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
10066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10067 if (!SWIG_IsOK(res1)) {
10068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10069 }
10070 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10071 ecode2 = SWIG_AsVal_int(obj1, &val2);
10072 if (!SWIG_IsOK(ecode2)) {
10073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
10074 }
10075 arg2 = static_cast< int >(val2);
10076 {
10077 PyThreadState* __tstate = wxPyBeginAllowThreads();
10078 (arg1)->SetCommandInt2(arg2);
10079 wxPyEndAllowThreads(__tstate);
10080 if (PyErr_Occurred()) SWIG_fail;
10081 }
10082 resultobj = SWIG_Py_Void();
10083 return resultobj;
10084 fail:
10085 return NULL;
10086 }
10087
10088
10089 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10090 PyObject *resultobj = 0;
10091 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10092 int result;
10093 void *argp1 = 0 ;
10094 int res1 = 0 ;
10095 PyObject *swig_obj[1] ;
10096
10097 if (!args) SWIG_fail;
10098 swig_obj[0] = args;
10099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10100 if (!SWIG_IsOK(res1)) {
10101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10102 }
10103 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10104 {
10105 PyThreadState* __tstate = wxPyBeginAllowThreads();
10106 result = (int)(arg1)->GetCommandInt2();
10107 wxPyEndAllowThreads(__tstate);
10108 if (PyErr_Occurred()) SWIG_fail;
10109 }
10110 resultobj = SWIG_From_int(static_cast< int >(result));
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10118 PyObject *obj;
10119 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10120 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
10121 return SWIG_Py_Void();
10122 }
10123
10124 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10125 return SWIG_Python_InitShadowInstance(args);
10126 }
10127
10128 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10129 PyObject *resultobj = 0;
10130 int arg1 = (int) -1 ;
10131 int arg2 = (int) -1 ;
10132 wxGridCellCoords *result = 0 ;
10133 int val1 ;
10134 int ecode1 = 0 ;
10135 int val2 ;
10136 int ecode2 = 0 ;
10137 PyObject * obj0 = 0 ;
10138 PyObject * obj1 = 0 ;
10139 char * kwnames[] = {
10140 (char *) "r",(char *) "c", NULL
10141 };
10142
10143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10144 if (obj0) {
10145 ecode1 = SWIG_AsVal_int(obj0, &val1);
10146 if (!SWIG_IsOK(ecode1)) {
10147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10148 }
10149 arg1 = static_cast< int >(val1);
10150 }
10151 if (obj1) {
10152 ecode2 = SWIG_AsVal_int(obj1, &val2);
10153 if (!SWIG_IsOK(ecode2)) {
10154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10155 }
10156 arg2 = static_cast< int >(val2);
10157 }
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10165 return resultobj;
10166 fail:
10167 return NULL;
10168 }
10169
10170
10171 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10172 PyObject *resultobj = 0;
10173 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10174 void *argp1 = 0 ;
10175 int res1 = 0 ;
10176 PyObject *swig_obj[1] ;
10177
10178 if (!args) SWIG_fail;
10179 swig_obj[0] = args;
10180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10181 if (!SWIG_IsOK(res1)) {
10182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10183 }
10184 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10185 {
10186 PyThreadState* __tstate = wxPyBeginAllowThreads();
10187 delete arg1;
10188
10189 wxPyEndAllowThreads(__tstate);
10190 if (PyErr_Occurred()) SWIG_fail;
10191 }
10192 resultobj = SWIG_Py_Void();
10193 return resultobj;
10194 fail:
10195 return NULL;
10196 }
10197
10198
10199 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10200 PyObject *resultobj = 0;
10201 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10202 int result;
10203 void *argp1 = 0 ;
10204 int res1 = 0 ;
10205 PyObject *swig_obj[1] ;
10206
10207 if (!args) SWIG_fail;
10208 swig_obj[0] = args;
10209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10210 if (!SWIG_IsOK(res1)) {
10211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10212 }
10213 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10214 {
10215 PyThreadState* __tstate = wxPyBeginAllowThreads();
10216 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 resultobj = SWIG_From_int(static_cast< int >(result));
10221 return resultobj;
10222 fail:
10223 return NULL;
10224 }
10225
10226
10227 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj = 0;
10229 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10230 int arg2 ;
10231 void *argp1 = 0 ;
10232 int res1 = 0 ;
10233 int val2 ;
10234 int ecode2 = 0 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "self",(char *) "n", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10245 }
10246 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10247 ecode2 = SWIG_AsVal_int(obj1, &val2);
10248 if (!SWIG_IsOK(ecode2)) {
10249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10250 }
10251 arg2 = static_cast< int >(val2);
10252 {
10253 PyThreadState* __tstate = wxPyBeginAllowThreads();
10254 (arg1)->SetRow(arg2);
10255 wxPyEndAllowThreads(__tstate);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 resultobj = SWIG_Py_Void();
10259 return resultobj;
10260 fail:
10261 return NULL;
10262 }
10263
10264
10265 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10266 PyObject *resultobj = 0;
10267 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10268 int result;
10269 void *argp1 = 0 ;
10270 int res1 = 0 ;
10271 PyObject *swig_obj[1] ;
10272
10273 if (!args) SWIG_fail;
10274 swig_obj[0] = args;
10275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10276 if (!SWIG_IsOK(res1)) {
10277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10278 }
10279 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10280 {
10281 PyThreadState* __tstate = wxPyBeginAllowThreads();
10282 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10283 wxPyEndAllowThreads(__tstate);
10284 if (PyErr_Occurred()) SWIG_fail;
10285 }
10286 resultobj = SWIG_From_int(static_cast< int >(result));
10287 return resultobj;
10288 fail:
10289 return NULL;
10290 }
10291
10292
10293 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10294 PyObject *resultobj = 0;
10295 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10296 int arg2 ;
10297 void *argp1 = 0 ;
10298 int res1 = 0 ;
10299 int val2 ;
10300 int ecode2 = 0 ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 char * kwnames[] = {
10304 (char *) "self",(char *) "n", NULL
10305 };
10306
10307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10309 if (!SWIG_IsOK(res1)) {
10310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10311 }
10312 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10313 ecode2 = SWIG_AsVal_int(obj1, &val2);
10314 if (!SWIG_IsOK(ecode2)) {
10315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10316 }
10317 arg2 = static_cast< int >(val2);
10318 {
10319 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 (arg1)->SetCol(arg2);
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 resultobj = SWIG_Py_Void();
10325 return resultobj;
10326 fail:
10327 return NULL;
10328 }
10329
10330
10331 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10332 PyObject *resultobj = 0;
10333 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10334 int arg2 ;
10335 int arg3 ;
10336 void *argp1 = 0 ;
10337 int res1 = 0 ;
10338 int val2 ;
10339 int ecode2 = 0 ;
10340 int val3 ;
10341 int ecode3 = 0 ;
10342 PyObject * obj0 = 0 ;
10343 PyObject * obj1 = 0 ;
10344 PyObject * obj2 = 0 ;
10345 char * kwnames[] = {
10346 (char *) "self",(char *) "row",(char *) "col", NULL
10347 };
10348
10349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10351 if (!SWIG_IsOK(res1)) {
10352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10353 }
10354 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10355 ecode2 = SWIG_AsVal_int(obj1, &val2);
10356 if (!SWIG_IsOK(ecode2)) {
10357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10358 }
10359 arg2 = static_cast< int >(val2);
10360 ecode3 = SWIG_AsVal_int(obj2, &val3);
10361 if (!SWIG_IsOK(ecode3)) {
10362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10363 }
10364 arg3 = static_cast< int >(val3);
10365 {
10366 PyThreadState* __tstate = wxPyBeginAllowThreads();
10367 (arg1)->Set(arg2,arg3);
10368 wxPyEndAllowThreads(__tstate);
10369 if (PyErr_Occurred()) SWIG_fail;
10370 }
10371 resultobj = SWIG_Py_Void();
10372 return resultobj;
10373 fail:
10374 return NULL;
10375 }
10376
10377
10378 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10379 PyObject *resultobj = 0;
10380 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10381 PyObject *arg2 = (PyObject *) 0 ;
10382 bool result;
10383 void *argp1 = 0 ;
10384 int res1 = 0 ;
10385 PyObject * obj0 = 0 ;
10386 PyObject * obj1 = 0 ;
10387 char * kwnames[] = {
10388 (char *) "self",(char *) "other", NULL
10389 };
10390
10391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10393 if (!SWIG_IsOK(res1)) {
10394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10395 }
10396 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10397 arg2 = obj1;
10398 {
10399 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10400 if (PyErr_Occurred()) SWIG_fail;
10401 }
10402 {
10403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10404 }
10405 return resultobj;
10406 fail:
10407 return NULL;
10408 }
10409
10410
10411 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10412 PyObject *resultobj = 0;
10413 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10414 PyObject *arg2 = (PyObject *) 0 ;
10415 bool result;
10416 void *argp1 = 0 ;
10417 int res1 = 0 ;
10418 PyObject * obj0 = 0 ;
10419 PyObject * obj1 = 0 ;
10420 char * kwnames[] = {
10421 (char *) "self",(char *) "other", NULL
10422 };
10423
10424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10426 if (!SWIG_IsOK(res1)) {
10427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10428 }
10429 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10430 arg2 = obj1;
10431 {
10432 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10433 if (PyErr_Occurred()) SWIG_fail;
10434 }
10435 {
10436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10437 }
10438 return resultobj;
10439 fail:
10440 return NULL;
10441 }
10442
10443
10444 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10445 PyObject *resultobj = 0;
10446 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10447 PyObject *result = 0 ;
10448 void *argp1 = 0 ;
10449 int res1 = 0 ;
10450 PyObject *swig_obj[1] ;
10451
10452 if (!args) SWIG_fail;
10453 swig_obj[0] = args;
10454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10455 if (!SWIG_IsOK(res1)) {
10456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10457 }
10458 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10459 {
10460 PyThreadState* __tstate = wxPyBeginAllowThreads();
10461 result = (PyObject *)wxGridCellCoords_Get(arg1);
10462 wxPyEndAllowThreads(__tstate);
10463 if (PyErr_Occurred()) SWIG_fail;
10464 }
10465 resultobj = result;
10466 return resultobj;
10467 fail:
10468 return NULL;
10469 }
10470
10471
10472 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10473 PyObject *obj;
10474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10475 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10476 return SWIG_Py_Void();
10477 }
10478
10479 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10480 return SWIG_Python_InitShadowInstance(args);
10481 }
10482
10483 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10484 PyObject *resultobj = 0;
10485 wxWindow *arg1 = (wxWindow *) 0 ;
10486 int arg2 = (int) -1 ;
10487 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10488 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10489 wxSize const &arg4_defvalue = wxDefaultSize ;
10490 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10491 long arg5 = (long) wxWANTS_CHARS ;
10492 wxString const &arg6_defvalue = wxPyGridNameStr ;
10493 wxString *arg6 = (wxString *) &arg6_defvalue ;
10494 wxGrid *result = 0 ;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 int val2 ;
10498 int ecode2 = 0 ;
10499 wxPoint temp3 ;
10500 wxSize temp4 ;
10501 long val5 ;
10502 int ecode5 = 0 ;
10503 bool temp6 = false ;
10504 PyObject * obj0 = 0 ;
10505 PyObject * obj1 = 0 ;
10506 PyObject * obj2 = 0 ;
10507 PyObject * obj3 = 0 ;
10508 PyObject * obj4 = 0 ;
10509 PyObject * obj5 = 0 ;
10510 char * kwnames[] = {
10511 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10512 };
10513
10514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10516 if (!SWIG_IsOK(res1)) {
10517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10518 }
10519 arg1 = reinterpret_cast< wxWindow * >(argp1);
10520 if (obj1) {
10521 ecode2 = SWIG_AsVal_int(obj1, &val2);
10522 if (!SWIG_IsOK(ecode2)) {
10523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10524 }
10525 arg2 = static_cast< int >(val2);
10526 }
10527 if (obj2) {
10528 {
10529 arg3 = &temp3;
10530 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10531 }
10532 }
10533 if (obj3) {
10534 {
10535 arg4 = &temp4;
10536 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10537 }
10538 }
10539 if (obj4) {
10540 ecode5 = SWIG_AsVal_long(obj4, &val5);
10541 if (!SWIG_IsOK(ecode5)) {
10542 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10543 }
10544 arg5 = static_cast< long >(val5);
10545 }
10546 if (obj5) {
10547 {
10548 arg6 = wxString_in_helper(obj5);
10549 if (arg6 == NULL) SWIG_fail;
10550 temp6 = true;
10551 }
10552 }
10553 {
10554 if (!wxPyCheckForApp()) SWIG_fail;
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10561 {
10562 if (temp6)
10563 delete arg6;
10564 }
10565 return resultobj;
10566 fail:
10567 {
10568 if (temp6)
10569 delete arg6;
10570 }
10571 return NULL;
10572 }
10573
10574
10575 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10576 PyObject *resultobj = 0;
10577 wxGrid *result = 0 ;
10578
10579 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10580 {
10581 if (!wxPyCheckForApp()) SWIG_fail;
10582 PyThreadState* __tstate = wxPyBeginAllowThreads();
10583 result = (wxGrid *)new wxGrid();
10584 wxPyEndAllowThreads(__tstate);
10585 if (PyErr_Occurred()) SWIG_fail;
10586 }
10587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10588 return resultobj;
10589 fail:
10590 return NULL;
10591 }
10592
10593
10594 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10595 PyObject *resultobj = 0;
10596 wxGrid *arg1 = (wxGrid *) 0 ;
10597 wxWindow *arg2 = (wxWindow *) 0 ;
10598 int arg3 = (int) -1 ;
10599 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10600 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10601 wxSize const &arg5_defvalue = wxDefaultSize ;
10602 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10603 long arg6 = (long) wxWANTS_CHARS ;
10604 wxString const &arg7_defvalue = wxPyGridNameStr ;
10605 wxString *arg7 = (wxString *) &arg7_defvalue ;
10606 bool result;
10607 void *argp1 = 0 ;
10608 int res1 = 0 ;
10609 void *argp2 = 0 ;
10610 int res2 = 0 ;
10611 int val3 ;
10612 int ecode3 = 0 ;
10613 wxPoint temp4 ;
10614 wxSize temp5 ;
10615 long val6 ;
10616 int ecode6 = 0 ;
10617 bool temp7 = false ;
10618 PyObject * obj0 = 0 ;
10619 PyObject * obj1 = 0 ;
10620 PyObject * obj2 = 0 ;
10621 PyObject * obj3 = 0 ;
10622 PyObject * obj4 = 0 ;
10623 PyObject * obj5 = 0 ;
10624 PyObject * obj6 = 0 ;
10625 char * kwnames[] = {
10626 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10627 };
10628
10629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10631 if (!SWIG_IsOK(res1)) {
10632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10633 }
10634 arg1 = reinterpret_cast< wxGrid * >(argp1);
10635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10636 if (!SWIG_IsOK(res2)) {
10637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10638 }
10639 arg2 = reinterpret_cast< wxWindow * >(argp2);
10640 if (obj2) {
10641 ecode3 = SWIG_AsVal_int(obj2, &val3);
10642 if (!SWIG_IsOK(ecode3)) {
10643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10644 }
10645 arg3 = static_cast< int >(val3);
10646 }
10647 if (obj3) {
10648 {
10649 arg4 = &temp4;
10650 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10651 }
10652 }
10653 if (obj4) {
10654 {
10655 arg5 = &temp5;
10656 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10657 }
10658 }
10659 if (obj5) {
10660 ecode6 = SWIG_AsVal_long(obj5, &val6);
10661 if (!SWIG_IsOK(ecode6)) {
10662 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10663 }
10664 arg6 = static_cast< long >(val6);
10665 }
10666 if (obj6) {
10667 {
10668 arg7 = wxString_in_helper(obj6);
10669 if (arg7 == NULL) SWIG_fail;
10670 temp7 = true;
10671 }
10672 }
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 {
10680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10681 }
10682 {
10683 if (temp7)
10684 delete arg7;
10685 }
10686 return resultobj;
10687 fail:
10688 {
10689 if (temp7)
10690 delete arg7;
10691 }
10692 return NULL;
10693 }
10694
10695
10696 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10697 PyObject *resultobj = 0;
10698 wxGrid *arg1 = (wxGrid *) 0 ;
10699 int arg2 ;
10700 int arg3 ;
10701 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10702 bool result;
10703 void *argp1 = 0 ;
10704 int res1 = 0 ;
10705 int val2 ;
10706 int ecode2 = 0 ;
10707 int val3 ;
10708 int ecode3 = 0 ;
10709 int val4 ;
10710 int ecode4 = 0 ;
10711 PyObject * obj0 = 0 ;
10712 PyObject * obj1 = 0 ;
10713 PyObject * obj2 = 0 ;
10714 PyObject * obj3 = 0 ;
10715 char * kwnames[] = {
10716 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10717 };
10718
10719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10721 if (!SWIG_IsOK(res1)) {
10722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10723 }
10724 arg1 = reinterpret_cast< wxGrid * >(argp1);
10725 ecode2 = SWIG_AsVal_int(obj1, &val2);
10726 if (!SWIG_IsOK(ecode2)) {
10727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10728 }
10729 arg2 = static_cast< int >(val2);
10730 ecode3 = SWIG_AsVal_int(obj2, &val3);
10731 if (!SWIG_IsOK(ecode3)) {
10732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10733 }
10734 arg3 = static_cast< int >(val3);
10735 if (obj3) {
10736 ecode4 = SWIG_AsVal_int(obj3, &val4);
10737 if (!SWIG_IsOK(ecode4)) {
10738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10739 }
10740 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10741 }
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 {
10749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10750 }
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10758 PyObject *resultobj = 0;
10759 wxGrid *arg1 = (wxGrid *) 0 ;
10760 WXGRIDSELECTIONMODES arg2 ;
10761 void *argp1 = 0 ;
10762 int res1 = 0 ;
10763 int val2 ;
10764 int ecode2 = 0 ;
10765 PyObject * obj0 = 0 ;
10766 PyObject * obj1 = 0 ;
10767 char * kwnames[] = {
10768 (char *) "self",(char *) "selmode", NULL
10769 };
10770
10771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10773 if (!SWIG_IsOK(res1)) {
10774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10775 }
10776 arg1 = reinterpret_cast< wxGrid * >(argp1);
10777 ecode2 = SWIG_AsVal_int(obj1, &val2);
10778 if (!SWIG_IsOK(ecode2)) {
10779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10780 }
10781 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 (arg1)->SetSelectionMode(arg2);
10785 wxPyEndAllowThreads(__tstate);
10786 if (PyErr_Occurred()) SWIG_fail;
10787 }
10788 resultobj = SWIG_Py_Void();
10789 return resultobj;
10790 fail:
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10796 PyObject *resultobj = 0;
10797 wxGrid *arg1 = (wxGrid *) 0 ;
10798 WXGRIDSELECTIONMODES result;
10799 void *argp1 = 0 ;
10800 int res1 = 0 ;
10801 PyObject *swig_obj[1] ;
10802
10803 if (!args) SWIG_fail;
10804 swig_obj[0] = args;
10805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10806 if (!SWIG_IsOK(res1)) {
10807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10808 }
10809 arg1 = reinterpret_cast< wxGrid * >(argp1);
10810 {
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10813 wxPyEndAllowThreads(__tstate);
10814 if (PyErr_Occurred()) SWIG_fail;
10815 }
10816 resultobj = SWIG_From_int(static_cast< int >(result));
10817 return resultobj;
10818 fail:
10819 return NULL;
10820 }
10821
10822
10823 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10824 PyObject *resultobj = 0;
10825 wxGrid *arg1 = (wxGrid *) 0 ;
10826 int result;
10827 void *argp1 = 0 ;
10828 int res1 = 0 ;
10829 PyObject *swig_obj[1] ;
10830
10831 if (!args) SWIG_fail;
10832 swig_obj[0] = args;
10833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10834 if (!SWIG_IsOK(res1)) {
10835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10836 }
10837 arg1 = reinterpret_cast< wxGrid * >(argp1);
10838 {
10839 PyThreadState* __tstate = wxPyBeginAllowThreads();
10840 result = (int)(arg1)->GetNumberRows();
10841 wxPyEndAllowThreads(__tstate);
10842 if (PyErr_Occurred()) SWIG_fail;
10843 }
10844 resultobj = SWIG_From_int(static_cast< int >(result));
10845 return resultobj;
10846 fail:
10847 return NULL;
10848 }
10849
10850
10851 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10852 PyObject *resultobj = 0;
10853 wxGrid *arg1 = (wxGrid *) 0 ;
10854 int result;
10855 void *argp1 = 0 ;
10856 int res1 = 0 ;
10857 PyObject *swig_obj[1] ;
10858
10859 if (!args) SWIG_fail;
10860 swig_obj[0] = args;
10861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10862 if (!SWIG_IsOK(res1)) {
10863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10864 }
10865 arg1 = reinterpret_cast< wxGrid * >(argp1);
10866 {
10867 PyThreadState* __tstate = wxPyBeginAllowThreads();
10868 result = (int)(arg1)->GetNumberCols();
10869 wxPyEndAllowThreads(__tstate);
10870 if (PyErr_Occurred()) SWIG_fail;
10871 }
10872 resultobj = SWIG_From_int(static_cast< int >(result));
10873 return resultobj;
10874 fail:
10875 return NULL;
10876 }
10877
10878
10879 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10880 PyObject *resultobj = 0;
10881 wxGrid *arg1 = (wxGrid *) 0 ;
10882 wxGridTableMessage *arg2 = 0 ;
10883 bool result;
10884 void *argp1 = 0 ;
10885 int res1 = 0 ;
10886 void *argp2 = 0 ;
10887 int res2 = 0 ;
10888 PyObject * obj0 = 0 ;
10889 PyObject * obj1 = 0 ;
10890 char * kwnames[] = {
10891 (char *) "self",(char *)"arg2", NULL
10892 };
10893
10894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10896 if (!SWIG_IsOK(res1)) {
10897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10898 }
10899 arg1 = reinterpret_cast< wxGrid * >(argp1);
10900 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10901 if (!SWIG_IsOK(res2)) {
10902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10903 }
10904 if (!argp2) {
10905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10906 }
10907 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10908 {
10909 PyThreadState* __tstate = wxPyBeginAllowThreads();
10910 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10911 wxPyEndAllowThreads(__tstate);
10912 if (PyErr_Occurred()) SWIG_fail;
10913 }
10914 {
10915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10916 }
10917 return resultobj;
10918 fail:
10919 return NULL;
10920 }
10921
10922
10923 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10924 PyObject *resultobj = 0;
10925 wxGrid *arg1 = (wxGrid *) 0 ;
10926 wxGridTableBase *result = 0 ;
10927 void *argp1 = 0 ;
10928 int res1 = 0 ;
10929 PyObject *swig_obj[1] ;
10930
10931 if (!args) SWIG_fail;
10932 swig_obj[0] = args;
10933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10934 if (!SWIG_IsOK(res1)) {
10935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10936 }
10937 arg1 = reinterpret_cast< wxGrid * >(argp1);
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10941 wxPyEndAllowThreads(__tstate);
10942 if (PyErr_Occurred()) SWIG_fail;
10943 }
10944 {
10945 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10946 }
10947 return resultobj;
10948 fail:
10949 return NULL;
10950 }
10951
10952
10953 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10954 PyObject *resultobj = 0;
10955 wxGrid *arg1 = (wxGrid *) 0 ;
10956 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10957 bool arg3 = (bool) false ;
10958 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10959 bool result;
10960 void *argp1 = 0 ;
10961 int res1 = 0 ;
10962 int res2 = 0 ;
10963 bool val3 ;
10964 int ecode3 = 0 ;
10965 int val4 ;
10966 int ecode4 = 0 ;
10967 PyObject * obj0 = 0 ;
10968 PyObject * obj1 = 0 ;
10969 PyObject * obj2 = 0 ;
10970 PyObject * obj3 = 0 ;
10971 char * kwnames[] = {
10972 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10973 };
10974
10975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10977 if (!SWIG_IsOK(res1)) {
10978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10979 }
10980 arg1 = reinterpret_cast< wxGrid * >(argp1);
10981 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10982 if (!SWIG_IsOK(res2)) {
10983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10984 }
10985 if (obj2) {
10986 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10987 if (!SWIG_IsOK(ecode3)) {
10988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10989 }
10990 arg3 = static_cast< bool >(val3);
10991 }
10992 if (obj3) {
10993 ecode4 = SWIG_AsVal_int(obj3, &val4);
10994 if (!SWIG_IsOK(ecode4)) {
10995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10996 }
10997 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10998 }
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 PyObject *resultobj = 0;
11016 wxGrid *arg1 = (wxGrid *) 0 ;
11017 void *argp1 = 0 ;
11018 int res1 = 0 ;
11019 PyObject *swig_obj[1] ;
11020
11021 if (!args) SWIG_fail;
11022 swig_obj[0] = args;
11023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11024 if (!SWIG_IsOK(res1)) {
11025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
11026 }
11027 arg1 = reinterpret_cast< wxGrid * >(argp1);
11028 {
11029 PyThreadState* __tstate = wxPyBeginAllowThreads();
11030 (arg1)->ClearGrid();
11031 wxPyEndAllowThreads(__tstate);
11032 if (PyErr_Occurred()) SWIG_fail;
11033 }
11034 resultobj = SWIG_Py_Void();
11035 return resultobj;
11036 fail:
11037 return NULL;
11038 }
11039
11040
11041 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj = 0;
11043 wxGrid *arg1 = (wxGrid *) 0 ;
11044 int arg2 = (int) 0 ;
11045 int arg3 = (int) 1 ;
11046 bool arg4 = (bool) true ;
11047 bool result;
11048 void *argp1 = 0 ;
11049 int res1 = 0 ;
11050 int val2 ;
11051 int ecode2 = 0 ;
11052 int val3 ;
11053 int ecode3 = 0 ;
11054 bool val4 ;
11055 int ecode4 = 0 ;
11056 PyObject * obj0 = 0 ;
11057 PyObject * obj1 = 0 ;
11058 PyObject * obj2 = 0 ;
11059 PyObject * obj3 = 0 ;
11060 char * kwnames[] = {
11061 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11062 };
11063
11064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11066 if (!SWIG_IsOK(res1)) {
11067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11068 }
11069 arg1 = reinterpret_cast< wxGrid * >(argp1);
11070 if (obj1) {
11071 ecode2 = SWIG_AsVal_int(obj1, &val2);
11072 if (!SWIG_IsOK(ecode2)) {
11073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
11074 }
11075 arg2 = static_cast< int >(val2);
11076 }
11077 if (obj2) {
11078 ecode3 = SWIG_AsVal_int(obj2, &val3);
11079 if (!SWIG_IsOK(ecode3)) {
11080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
11081 }
11082 arg3 = static_cast< int >(val3);
11083 }
11084 if (obj3) {
11085 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11086 if (!SWIG_IsOK(ecode4)) {
11087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
11088 }
11089 arg4 = static_cast< bool >(val4);
11090 }
11091 {
11092 PyThreadState* __tstate = wxPyBeginAllowThreads();
11093 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 {
11098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11099 }
11100 return resultobj;
11101 fail:
11102 return NULL;
11103 }
11104
11105
11106 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11107 PyObject *resultobj = 0;
11108 wxGrid *arg1 = (wxGrid *) 0 ;
11109 int arg2 = (int) 1 ;
11110 bool arg3 = (bool) true ;
11111 bool result;
11112 void *argp1 = 0 ;
11113 int res1 = 0 ;
11114 int val2 ;
11115 int ecode2 = 0 ;
11116 bool val3 ;
11117 int ecode3 = 0 ;
11118 PyObject * obj0 = 0 ;
11119 PyObject * obj1 = 0 ;
11120 PyObject * obj2 = 0 ;
11121 char * kwnames[] = {
11122 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
11123 };
11124
11125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11127 if (!SWIG_IsOK(res1)) {
11128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11129 }
11130 arg1 = reinterpret_cast< wxGrid * >(argp1);
11131 if (obj1) {
11132 ecode2 = SWIG_AsVal_int(obj1, &val2);
11133 if (!SWIG_IsOK(ecode2)) {
11134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11135 }
11136 arg2 = static_cast< int >(val2);
11137 }
11138 if (obj2) {
11139 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11140 if (!SWIG_IsOK(ecode3)) {
11141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11142 }
11143 arg3 = static_cast< bool >(val3);
11144 }
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (bool)(arg1)->AppendRows(arg2,arg3);
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 {
11152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11153 }
11154 return resultobj;
11155 fail:
11156 return NULL;
11157 }
11158
11159
11160 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11161 PyObject *resultobj = 0;
11162 wxGrid *arg1 = (wxGrid *) 0 ;
11163 int arg2 = (int) 0 ;
11164 int arg3 = (int) 1 ;
11165 bool arg4 = (bool) true ;
11166 bool result;
11167 void *argp1 = 0 ;
11168 int res1 = 0 ;
11169 int val2 ;
11170 int ecode2 = 0 ;
11171 int val3 ;
11172 int ecode3 = 0 ;
11173 bool val4 ;
11174 int ecode4 = 0 ;
11175 PyObject * obj0 = 0 ;
11176 PyObject * obj1 = 0 ;
11177 PyObject * obj2 = 0 ;
11178 PyObject * obj3 = 0 ;
11179 char * kwnames[] = {
11180 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11181 };
11182
11183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11185 if (!SWIG_IsOK(res1)) {
11186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11187 }
11188 arg1 = reinterpret_cast< wxGrid * >(argp1);
11189 if (obj1) {
11190 ecode2 = SWIG_AsVal_int(obj1, &val2);
11191 if (!SWIG_IsOK(ecode2)) {
11192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11193 }
11194 arg2 = static_cast< int >(val2);
11195 }
11196 if (obj2) {
11197 ecode3 = SWIG_AsVal_int(obj2, &val3);
11198 if (!SWIG_IsOK(ecode3)) {
11199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11200 }
11201 arg3 = static_cast< int >(val3);
11202 }
11203 if (obj3) {
11204 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11205 if (!SWIG_IsOK(ecode4)) {
11206 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11207 }
11208 arg4 = static_cast< bool >(val4);
11209 }
11210 {
11211 PyThreadState* __tstate = wxPyBeginAllowThreads();
11212 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
11213 wxPyEndAllowThreads(__tstate);
11214 if (PyErr_Occurred()) SWIG_fail;
11215 }
11216 {
11217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11218 }
11219 return resultobj;
11220 fail:
11221 return NULL;
11222 }
11223
11224
11225 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11226 PyObject *resultobj = 0;
11227 wxGrid *arg1 = (wxGrid *) 0 ;
11228 int arg2 = (int) 0 ;
11229 int arg3 = (int) 1 ;
11230 bool arg4 = (bool) true ;
11231 bool result;
11232 void *argp1 = 0 ;
11233 int res1 = 0 ;
11234 int val2 ;
11235 int ecode2 = 0 ;
11236 int val3 ;
11237 int ecode3 = 0 ;
11238 bool val4 ;
11239 int ecode4 = 0 ;
11240 PyObject * obj0 = 0 ;
11241 PyObject * obj1 = 0 ;
11242 PyObject * obj2 = 0 ;
11243 PyObject * obj3 = 0 ;
11244 char * kwnames[] = {
11245 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11246 };
11247
11248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11250 if (!SWIG_IsOK(res1)) {
11251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11252 }
11253 arg1 = reinterpret_cast< wxGrid * >(argp1);
11254 if (obj1) {
11255 ecode2 = SWIG_AsVal_int(obj1, &val2);
11256 if (!SWIG_IsOK(ecode2)) {
11257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
11258 }
11259 arg2 = static_cast< int >(val2);
11260 }
11261 if (obj2) {
11262 ecode3 = SWIG_AsVal_int(obj2, &val3);
11263 if (!SWIG_IsOK(ecode3)) {
11264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
11265 }
11266 arg3 = static_cast< int >(val3);
11267 }
11268 if (obj3) {
11269 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11270 if (!SWIG_IsOK(ecode4)) {
11271 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11272 }
11273 arg4 = static_cast< bool >(val4);
11274 }
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11278 wxPyEndAllowThreads(__tstate);
11279 if (PyErr_Occurred()) SWIG_fail;
11280 }
11281 {
11282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11283 }
11284 return resultobj;
11285 fail:
11286 return NULL;
11287 }
11288
11289
11290 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11291 PyObject *resultobj = 0;
11292 wxGrid *arg1 = (wxGrid *) 0 ;
11293 int arg2 = (int) 1 ;
11294 bool arg3 = (bool) true ;
11295 bool result;
11296 void *argp1 = 0 ;
11297 int res1 = 0 ;
11298 int val2 ;
11299 int ecode2 = 0 ;
11300 bool val3 ;
11301 int ecode3 = 0 ;
11302 PyObject * obj0 = 0 ;
11303 PyObject * obj1 = 0 ;
11304 PyObject * obj2 = 0 ;
11305 char * kwnames[] = {
11306 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11307 };
11308
11309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",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_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11313 }
11314 arg1 = reinterpret_cast< wxGrid * >(argp1);
11315 if (obj1) {
11316 ecode2 = SWIG_AsVal_int(obj1, &val2);
11317 if (!SWIG_IsOK(ecode2)) {
11318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11319 }
11320 arg2 = static_cast< int >(val2);
11321 }
11322 if (obj2) {
11323 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11324 if (!SWIG_IsOK(ecode3)) {
11325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11326 }
11327 arg3 = static_cast< bool >(val3);
11328 }
11329 {
11330 PyThreadState* __tstate = wxPyBeginAllowThreads();
11331 result = (bool)(arg1)->AppendCols(arg2,arg3);
11332 wxPyEndAllowThreads(__tstate);
11333 if (PyErr_Occurred()) SWIG_fail;
11334 }
11335 {
11336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11337 }
11338 return resultobj;
11339 fail:
11340 return NULL;
11341 }
11342
11343
11344 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11345 PyObject *resultobj = 0;
11346 wxGrid *arg1 = (wxGrid *) 0 ;
11347 int arg2 = (int) 0 ;
11348 int arg3 = (int) 1 ;
11349 bool arg4 = (bool) true ;
11350 bool result;
11351 void *argp1 = 0 ;
11352 int res1 = 0 ;
11353 int val2 ;
11354 int ecode2 = 0 ;
11355 int val3 ;
11356 int ecode3 = 0 ;
11357 bool val4 ;
11358 int ecode4 = 0 ;
11359 PyObject * obj0 = 0 ;
11360 PyObject * obj1 = 0 ;
11361 PyObject * obj2 = 0 ;
11362 PyObject * obj3 = 0 ;
11363 char * kwnames[] = {
11364 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11365 };
11366
11367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11369 if (!SWIG_IsOK(res1)) {
11370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11371 }
11372 arg1 = reinterpret_cast< wxGrid * >(argp1);
11373 if (obj1) {
11374 ecode2 = SWIG_AsVal_int(obj1, &val2);
11375 if (!SWIG_IsOK(ecode2)) {
11376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11377 }
11378 arg2 = static_cast< int >(val2);
11379 }
11380 if (obj2) {
11381 ecode3 = SWIG_AsVal_int(obj2, &val3);
11382 if (!SWIG_IsOK(ecode3)) {
11383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11384 }
11385 arg3 = static_cast< int >(val3);
11386 }
11387 if (obj3) {
11388 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11389 if (!SWIG_IsOK(ecode4)) {
11390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11391 }
11392 arg4 = static_cast< bool >(val4);
11393 }
11394 {
11395 PyThreadState* __tstate = wxPyBeginAllowThreads();
11396 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 {
11401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj = 0;
11411 wxGrid *arg1 = (wxGrid *) 0 ;
11412 wxDC *arg2 = 0 ;
11413 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11414 void *argp1 = 0 ;
11415 int res1 = 0 ;
11416 void *argp2 = 0 ;
11417 int res2 = 0 ;
11418 void *argp3 = 0 ;
11419 int res3 = 0 ;
11420 PyObject * obj0 = 0 ;
11421 PyObject * obj1 = 0 ;
11422 PyObject * obj2 = 0 ;
11423 char * kwnames[] = {
11424 (char *) "self",(char *) "dc",(char *) "attr", NULL
11425 };
11426
11427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11429 if (!SWIG_IsOK(res1)) {
11430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11431 }
11432 arg1 = reinterpret_cast< wxGrid * >(argp1);
11433 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11434 if (!SWIG_IsOK(res2)) {
11435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11436 }
11437 if (!argp2) {
11438 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11439 }
11440 arg2 = reinterpret_cast< wxDC * >(argp2);
11441 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11442 if (!SWIG_IsOK(res3)) {
11443 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11444 }
11445 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 resultobj = SWIG_Py_Void();
11453 return resultobj;
11454 fail:
11455 return NULL;
11456 }
11457
11458
11459 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11460 PyObject *resultobj = 0;
11461 wxGrid *arg1 = (wxGrid *) 0 ;
11462 wxDC *arg2 = 0 ;
11463 wxString *arg3 = 0 ;
11464 wxRect *arg4 = 0 ;
11465 int arg5 = (int) wxLEFT ;
11466 int arg6 = (int) wxTOP ;
11467 int arg7 = (int) wxHORIZONTAL ;
11468 void *argp1 = 0 ;
11469 int res1 = 0 ;
11470 void *argp2 = 0 ;
11471 int res2 = 0 ;
11472 bool temp3 = false ;
11473 wxRect temp4 ;
11474 int val5 ;
11475 int ecode5 = 0 ;
11476 int val6 ;
11477 int ecode6 = 0 ;
11478 int val7 ;
11479 int ecode7 = 0 ;
11480 PyObject * obj0 = 0 ;
11481 PyObject * obj1 = 0 ;
11482 PyObject * obj2 = 0 ;
11483 PyObject * obj3 = 0 ;
11484 PyObject * obj4 = 0 ;
11485 PyObject * obj5 = 0 ;
11486 PyObject * obj6 = 0 ;
11487 char * kwnames[] = {
11488 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11489 };
11490
11491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11493 if (!SWIG_IsOK(res1)) {
11494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11495 }
11496 arg1 = reinterpret_cast< wxGrid * >(argp1);
11497 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11498 if (!SWIG_IsOK(res2)) {
11499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11500 }
11501 if (!argp2) {
11502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11503 }
11504 arg2 = reinterpret_cast< wxDC * >(argp2);
11505 {
11506 arg3 = wxString_in_helper(obj2);
11507 if (arg3 == NULL) SWIG_fail;
11508 temp3 = true;
11509 }
11510 {
11511 arg4 = &temp4;
11512 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11513 }
11514 if (obj4) {
11515 ecode5 = SWIG_AsVal_int(obj4, &val5);
11516 if (!SWIG_IsOK(ecode5)) {
11517 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11518 }
11519 arg5 = static_cast< int >(val5);
11520 }
11521 if (obj5) {
11522 ecode6 = SWIG_AsVal_int(obj5, &val6);
11523 if (!SWIG_IsOK(ecode6)) {
11524 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11525 }
11526 arg6 = static_cast< int >(val6);
11527 }
11528 if (obj6) {
11529 ecode7 = SWIG_AsVal_int(obj6, &val7);
11530 if (!SWIG_IsOK(ecode7)) {
11531 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11532 }
11533 arg7 = static_cast< int >(val7);
11534 }
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 resultobj = SWIG_Py_Void();
11542 {
11543 if (temp3)
11544 delete arg3;
11545 }
11546 return resultobj;
11547 fail:
11548 {
11549 if (temp3)
11550 delete arg3;
11551 }
11552 return NULL;
11553 }
11554
11555
11556 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11557 PyObject *resultobj = 0;
11558 wxGrid *arg1 = (wxGrid *) 0 ;
11559 wxDC *arg2 = 0 ;
11560 wxArrayString *arg3 = 0 ;
11561 long *arg4 = (long *) 0 ;
11562 long *arg5 = (long *) 0 ;
11563 void *argp1 = 0 ;
11564 int res1 = 0 ;
11565 void *argp2 = 0 ;
11566 int res2 = 0 ;
11567 bool temp3 = false ;
11568 long temp4 ;
11569 int res4 = SWIG_TMPOBJ ;
11570 long temp5 ;
11571 int res5 = SWIG_TMPOBJ ;
11572 PyObject * obj0 = 0 ;
11573 PyObject * obj1 = 0 ;
11574 PyObject * obj2 = 0 ;
11575 char * kwnames[] = {
11576 (char *) "self",(char *) "dc",(char *) "lines", NULL
11577 };
11578
11579 arg4 = &temp4;
11580 arg5 = &temp5;
11581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11585 }
11586 arg1 = reinterpret_cast< wxGrid * >(argp1);
11587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11588 if (!SWIG_IsOK(res2)) {
11589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11590 }
11591 if (!argp2) {
11592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11593 }
11594 arg2 = reinterpret_cast< wxDC * >(argp2);
11595 {
11596 if (! PySequence_Check(obj2)) {
11597 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11598 SWIG_fail;
11599 }
11600 arg3 = new wxArrayString;
11601 temp3 = true;
11602 int i, len=PySequence_Length(obj2);
11603 for (i=0; i<len; i++) {
11604 PyObject* item = PySequence_GetItem(obj2, i);
11605 wxString* s = wxString_in_helper(item);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 arg3->Add(*s);
11608 delete s;
11609 Py_DECREF(item);
11610 }
11611 }
11612 {
11613 PyThreadState* __tstate = wxPyBeginAllowThreads();
11614 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11615 wxPyEndAllowThreads(__tstate);
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 resultobj = SWIG_Py_Void();
11619 if (SWIG_IsTmpObj(res4)) {
11620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11621 } else {
11622 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11624 }
11625 if (SWIG_IsTmpObj(res5)) {
11626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11627 } else {
11628 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11630 }
11631 {
11632 if (temp3) delete arg3;
11633 }
11634 return resultobj;
11635 fail:
11636 {
11637 if (temp3) delete arg3;
11638 }
11639 return NULL;
11640 }
11641
11642
11643 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11644 PyObject *resultobj = 0;
11645 wxGrid *arg1 = (wxGrid *) 0 ;
11646 void *argp1 = 0 ;
11647 int res1 = 0 ;
11648 PyObject *swig_obj[1] ;
11649
11650 if (!args) SWIG_fail;
11651 swig_obj[0] = args;
11652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11655 }
11656 arg1 = reinterpret_cast< wxGrid * >(argp1);
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 (arg1)->BeginBatch();
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 resultobj = SWIG_Py_Void();
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11671 PyObject *resultobj = 0;
11672 wxGrid *arg1 = (wxGrid *) 0 ;
11673 void *argp1 = 0 ;
11674 int res1 = 0 ;
11675 PyObject *swig_obj[1] ;
11676
11677 if (!args) SWIG_fail;
11678 swig_obj[0] = args;
11679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11680 if (!SWIG_IsOK(res1)) {
11681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11682 }
11683 arg1 = reinterpret_cast< wxGrid * >(argp1);
11684 {
11685 PyThreadState* __tstate = wxPyBeginAllowThreads();
11686 (arg1)->EndBatch();
11687 wxPyEndAllowThreads(__tstate);
11688 if (PyErr_Occurred()) SWIG_fail;
11689 }
11690 resultobj = SWIG_Py_Void();
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11698 PyObject *resultobj = 0;
11699 wxGrid *arg1 = (wxGrid *) 0 ;
11700 int result;
11701 void *argp1 = 0 ;
11702 int res1 = 0 ;
11703 PyObject *swig_obj[1] ;
11704
11705 if (!args) SWIG_fail;
11706 swig_obj[0] = args;
11707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11708 if (!SWIG_IsOK(res1)) {
11709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11710 }
11711 arg1 = reinterpret_cast< wxGrid * >(argp1);
11712 {
11713 PyThreadState* __tstate = wxPyBeginAllowThreads();
11714 result = (int)(arg1)->GetBatchCount();
11715 wxPyEndAllowThreads(__tstate);
11716 if (PyErr_Occurred()) SWIG_fail;
11717 }
11718 resultobj = SWIG_From_int(static_cast< int >(result));
11719 return resultobj;
11720 fail:
11721 return NULL;
11722 }
11723
11724
11725 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11726 PyObject *resultobj = 0;
11727 wxGrid *arg1 = (wxGrid *) 0 ;
11728 void *argp1 = 0 ;
11729 int res1 = 0 ;
11730 PyObject *swig_obj[1] ;
11731
11732 if (!args) SWIG_fail;
11733 swig_obj[0] = args;
11734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11737 }
11738 arg1 = reinterpret_cast< wxGrid * >(argp1);
11739 {
11740 PyThreadState* __tstate = wxPyBeginAllowThreads();
11741 (arg1)->ForceRefresh();
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 resultobj = SWIG_Py_Void();
11746 return resultobj;
11747 fail:
11748 return NULL;
11749 }
11750
11751
11752 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11753 PyObject *resultobj = 0;
11754 wxGrid *arg1 = (wxGrid *) 0 ;
11755 bool result;
11756 void *argp1 = 0 ;
11757 int res1 = 0 ;
11758 PyObject *swig_obj[1] ;
11759
11760 if (!args) SWIG_fail;
11761 swig_obj[0] = args;
11762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11763 if (!SWIG_IsOK(res1)) {
11764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11765 }
11766 arg1 = reinterpret_cast< wxGrid * >(argp1);
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (bool)(arg1)->IsEditable();
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj = 0;
11784 wxGrid *arg1 = (wxGrid *) 0 ;
11785 bool arg2 ;
11786 void *argp1 = 0 ;
11787 int res1 = 0 ;
11788 bool val2 ;
11789 int ecode2 = 0 ;
11790 PyObject * obj0 = 0 ;
11791 PyObject * obj1 = 0 ;
11792 char * kwnames[] = {
11793 (char *) "self",(char *) "edit", NULL
11794 };
11795
11796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11798 if (!SWIG_IsOK(res1)) {
11799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11800 }
11801 arg1 = reinterpret_cast< wxGrid * >(argp1);
11802 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11803 if (!SWIG_IsOK(ecode2)) {
11804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11805 }
11806 arg2 = static_cast< bool >(val2);
11807 {
11808 PyThreadState* __tstate = wxPyBeginAllowThreads();
11809 (arg1)->EnableEditing(arg2);
11810 wxPyEndAllowThreads(__tstate);
11811 if (PyErr_Occurred()) SWIG_fail;
11812 }
11813 resultobj = SWIG_Py_Void();
11814 return resultobj;
11815 fail:
11816 return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11821 PyObject *resultobj = 0;
11822 wxGrid *arg1 = (wxGrid *) 0 ;
11823 bool arg2 = (bool) true ;
11824 void *argp1 = 0 ;
11825 int res1 = 0 ;
11826 bool val2 ;
11827 int ecode2 = 0 ;
11828 PyObject * obj0 = 0 ;
11829 PyObject * obj1 = 0 ;
11830 char * kwnames[] = {
11831 (char *) "self",(char *) "enable", NULL
11832 };
11833
11834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11836 if (!SWIG_IsOK(res1)) {
11837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11838 }
11839 arg1 = reinterpret_cast< wxGrid * >(argp1);
11840 if (obj1) {
11841 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11842 if (!SWIG_IsOK(ecode2)) {
11843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11844 }
11845 arg2 = static_cast< bool >(val2);
11846 }
11847 {
11848 PyThreadState* __tstate = wxPyBeginAllowThreads();
11849 (arg1)->EnableCellEditControl(arg2);
11850 wxPyEndAllowThreads(__tstate);
11851 if (PyErr_Occurred()) SWIG_fail;
11852 }
11853 resultobj = SWIG_Py_Void();
11854 return resultobj;
11855 fail:
11856 return NULL;
11857 }
11858
11859
11860 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11861 PyObject *resultobj = 0;
11862 wxGrid *arg1 = (wxGrid *) 0 ;
11863 void *argp1 = 0 ;
11864 int res1 = 0 ;
11865 PyObject *swig_obj[1] ;
11866
11867 if (!args) SWIG_fail;
11868 swig_obj[0] = args;
11869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11870 if (!SWIG_IsOK(res1)) {
11871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11872 }
11873 arg1 = reinterpret_cast< wxGrid * >(argp1);
11874 {
11875 PyThreadState* __tstate = wxPyBeginAllowThreads();
11876 (arg1)->DisableCellEditControl();
11877 wxPyEndAllowThreads(__tstate);
11878 if (PyErr_Occurred()) SWIG_fail;
11879 }
11880 resultobj = SWIG_Py_Void();
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11888 PyObject *resultobj = 0;
11889 wxGrid *arg1 = (wxGrid *) 0 ;
11890 bool result;
11891 void *argp1 = 0 ;
11892 int res1 = 0 ;
11893 PyObject *swig_obj[1] ;
11894
11895 if (!args) SWIG_fail;
11896 swig_obj[0] = args;
11897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11898 if (!SWIG_IsOK(res1)) {
11899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11900 }
11901 arg1 = reinterpret_cast< wxGrid * >(argp1);
11902 {
11903 PyThreadState* __tstate = wxPyBeginAllowThreads();
11904 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 {
11909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11910 }
11911 return resultobj;
11912 fail:
11913 return NULL;
11914 }
11915
11916
11917 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11918 PyObject *resultobj = 0;
11919 wxGrid *arg1 = (wxGrid *) 0 ;
11920 bool result;
11921 void *argp1 = 0 ;
11922 int res1 = 0 ;
11923 PyObject *swig_obj[1] ;
11924
11925 if (!args) SWIG_fail;
11926 swig_obj[0] = args;
11927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11928 if (!SWIG_IsOK(res1)) {
11929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11930 }
11931 arg1 = reinterpret_cast< wxGrid * >(argp1);
11932 {
11933 PyThreadState* __tstate = wxPyBeginAllowThreads();
11934 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11935 wxPyEndAllowThreads(__tstate);
11936 if (PyErr_Occurred()) SWIG_fail;
11937 }
11938 {
11939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11940 }
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11948 PyObject *resultobj = 0;
11949 wxGrid *arg1 = (wxGrid *) 0 ;
11950 bool result;
11951 void *argp1 = 0 ;
11952 int res1 = 0 ;
11953 PyObject *swig_obj[1] ;
11954
11955 if (!args) SWIG_fail;
11956 swig_obj[0] = args;
11957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11958 if (!SWIG_IsOK(res1)) {
11959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11960 }
11961 arg1 = reinterpret_cast< wxGrid * >(argp1);
11962 {
11963 PyThreadState* __tstate = wxPyBeginAllowThreads();
11964 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11965 wxPyEndAllowThreads(__tstate);
11966 if (PyErr_Occurred()) SWIG_fail;
11967 }
11968 {
11969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11970 }
11971 return resultobj;
11972 fail:
11973 return NULL;
11974 }
11975
11976
11977 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11978 PyObject *resultobj = 0;
11979 wxGrid *arg1 = (wxGrid *) 0 ;
11980 bool result;
11981 void *argp1 = 0 ;
11982 int res1 = 0 ;
11983 PyObject *swig_obj[1] ;
11984
11985 if (!args) SWIG_fail;
11986 swig_obj[0] = args;
11987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11988 if (!SWIG_IsOK(res1)) {
11989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11990 }
11991 arg1 = reinterpret_cast< wxGrid * >(argp1);
11992 {
11993 PyThreadState* __tstate = wxPyBeginAllowThreads();
11994 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11995 wxPyEndAllowThreads(__tstate);
11996 if (PyErr_Occurred()) SWIG_fail;
11997 }
11998 {
11999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12000 }
12001 return resultobj;
12002 fail:
12003 return NULL;
12004 }
12005
12006
12007 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12008 PyObject *resultobj = 0;
12009 wxGrid *arg1 = (wxGrid *) 0 ;
12010 void *argp1 = 0 ;
12011 int res1 = 0 ;
12012 PyObject *swig_obj[1] ;
12013
12014 if (!args) SWIG_fail;
12015 swig_obj[0] = args;
12016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12017 if (!SWIG_IsOK(res1)) {
12018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12019 }
12020 arg1 = reinterpret_cast< wxGrid * >(argp1);
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 (arg1)->ShowCellEditControl();
12024 wxPyEndAllowThreads(__tstate);
12025 if (PyErr_Occurred()) SWIG_fail;
12026 }
12027 resultobj = SWIG_Py_Void();
12028 return resultobj;
12029 fail:
12030 return NULL;
12031 }
12032
12033
12034 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12035 PyObject *resultobj = 0;
12036 wxGrid *arg1 = (wxGrid *) 0 ;
12037 void *argp1 = 0 ;
12038 int res1 = 0 ;
12039 PyObject *swig_obj[1] ;
12040
12041 if (!args) SWIG_fail;
12042 swig_obj[0] = args;
12043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12044 if (!SWIG_IsOK(res1)) {
12045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12046 }
12047 arg1 = reinterpret_cast< wxGrid * >(argp1);
12048 {
12049 PyThreadState* __tstate = wxPyBeginAllowThreads();
12050 (arg1)->HideCellEditControl();
12051 wxPyEndAllowThreads(__tstate);
12052 if (PyErr_Occurred()) SWIG_fail;
12053 }
12054 resultobj = SWIG_Py_Void();
12055 return resultobj;
12056 fail:
12057 return NULL;
12058 }
12059
12060
12061 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12062 PyObject *resultobj = 0;
12063 wxGrid *arg1 = (wxGrid *) 0 ;
12064 void *argp1 = 0 ;
12065 int res1 = 0 ;
12066 PyObject *swig_obj[1] ;
12067
12068 if (!args) SWIG_fail;
12069 swig_obj[0] = args;
12070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12071 if (!SWIG_IsOK(res1)) {
12072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12073 }
12074 arg1 = reinterpret_cast< wxGrid * >(argp1);
12075 {
12076 PyThreadState* __tstate = wxPyBeginAllowThreads();
12077 (arg1)->SaveEditControlValue();
12078 wxPyEndAllowThreads(__tstate);
12079 if (PyErr_Occurred()) SWIG_fail;
12080 }
12081 resultobj = SWIG_Py_Void();
12082 return resultobj;
12083 fail:
12084 return NULL;
12085 }
12086
12087
12088 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj = 0;
12090 wxGrid *arg1 = (wxGrid *) 0 ;
12091 int arg2 ;
12092 int arg3 ;
12093 wxGridCellCoords result;
12094 void *argp1 = 0 ;
12095 int res1 = 0 ;
12096 int val2 ;
12097 int ecode2 = 0 ;
12098 int val3 ;
12099 int ecode3 = 0 ;
12100 PyObject * obj0 = 0 ;
12101 PyObject * obj1 = 0 ;
12102 PyObject * obj2 = 0 ;
12103 char * kwnames[] = {
12104 (char *) "self",(char *) "x",(char *) "y", NULL
12105 };
12106
12107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12109 if (!SWIG_IsOK(res1)) {
12110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
12111 }
12112 arg1 = reinterpret_cast< wxGrid * >(argp1);
12113 ecode2 = SWIG_AsVal_int(obj1, &val2);
12114 if (!SWIG_IsOK(ecode2)) {
12115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
12116 }
12117 arg2 = static_cast< int >(val2);
12118 ecode3 = SWIG_AsVal_int(obj2, &val3);
12119 if (!SWIG_IsOK(ecode3)) {
12120 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
12121 }
12122 arg3 = static_cast< int >(val3);
12123 {
12124 PyThreadState* __tstate = wxPyBeginAllowThreads();
12125 result = wxGrid_XYToCell(arg1,arg2,arg3);
12126 wxPyEndAllowThreads(__tstate);
12127 if (PyErr_Occurred()) SWIG_fail;
12128 }
12129 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12130 return resultobj;
12131 fail:
12132 return NULL;
12133 }
12134
12135
12136 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12137 PyObject *resultobj = 0;
12138 wxGrid *arg1 = (wxGrid *) 0 ;
12139 int arg2 ;
12140 int result;
12141 void *argp1 = 0 ;
12142 int res1 = 0 ;
12143 int val2 ;
12144 int ecode2 = 0 ;
12145 PyObject * obj0 = 0 ;
12146 PyObject * obj1 = 0 ;
12147 char * kwnames[] = {
12148 (char *) "self",(char *) "y", NULL
12149 };
12150
12151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12153 if (!SWIG_IsOK(res1)) {
12154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12155 }
12156 arg1 = reinterpret_cast< wxGrid * >(argp1);
12157 ecode2 = SWIG_AsVal_int(obj1, &val2);
12158 if (!SWIG_IsOK(ecode2)) {
12159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12160 }
12161 arg2 = static_cast< int >(val2);
12162 {
12163 PyThreadState* __tstate = wxPyBeginAllowThreads();
12164 result = (int)(arg1)->YToRow(arg2);
12165 wxPyEndAllowThreads(__tstate);
12166 if (PyErr_Occurred()) SWIG_fail;
12167 }
12168 resultobj = SWIG_From_int(static_cast< int >(result));
12169 return resultobj;
12170 fail:
12171 return NULL;
12172 }
12173
12174
12175 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj = 0;
12177 wxGrid *arg1 = (wxGrid *) 0 ;
12178 int arg2 ;
12179 bool arg3 = (bool) false ;
12180 int result;
12181 void *argp1 = 0 ;
12182 int res1 = 0 ;
12183 int val2 ;
12184 int ecode2 = 0 ;
12185 bool val3 ;
12186 int ecode3 = 0 ;
12187 PyObject * obj0 = 0 ;
12188 PyObject * obj1 = 0 ;
12189 PyObject * obj2 = 0 ;
12190 char * kwnames[] = {
12191 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
12192 };
12193
12194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12196 if (!SWIG_IsOK(res1)) {
12197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12198 }
12199 arg1 = reinterpret_cast< wxGrid * >(argp1);
12200 ecode2 = SWIG_AsVal_int(obj1, &val2);
12201 if (!SWIG_IsOK(ecode2)) {
12202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12203 }
12204 arg2 = static_cast< int >(val2);
12205 if (obj2) {
12206 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12207 if (!SWIG_IsOK(ecode3)) {
12208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
12209 }
12210 arg3 = static_cast< bool >(val3);
12211 }
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 result = (int)(arg1)->XToCol(arg2,arg3);
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 resultobj = SWIG_From_int(static_cast< int >(result));
12219 return resultobj;
12220 fail:
12221 return NULL;
12222 }
12223
12224
12225 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12226 PyObject *resultobj = 0;
12227 wxGrid *arg1 = (wxGrid *) 0 ;
12228 int arg2 ;
12229 int result;
12230 void *argp1 = 0 ;
12231 int res1 = 0 ;
12232 int val2 ;
12233 int ecode2 = 0 ;
12234 PyObject * obj0 = 0 ;
12235 PyObject * obj1 = 0 ;
12236 char * kwnames[] = {
12237 (char *) "self",(char *) "y", NULL
12238 };
12239
12240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12242 if (!SWIG_IsOK(res1)) {
12243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12244 }
12245 arg1 = reinterpret_cast< wxGrid * >(argp1);
12246 ecode2 = SWIG_AsVal_int(obj1, &val2);
12247 if (!SWIG_IsOK(ecode2)) {
12248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12249 }
12250 arg2 = static_cast< int >(val2);
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (int)(arg1)->YToEdgeOfRow(arg2);
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 resultobj = SWIG_From_int(static_cast< int >(result));
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj = 0;
12266 wxGrid *arg1 = (wxGrid *) 0 ;
12267 int arg2 ;
12268 int result;
12269 void *argp1 = 0 ;
12270 int res1 = 0 ;
12271 int val2 ;
12272 int ecode2 = 0 ;
12273 PyObject * obj0 = 0 ;
12274 PyObject * obj1 = 0 ;
12275 char * kwnames[] = {
12276 (char *) "self",(char *) "x", NULL
12277 };
12278
12279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12281 if (!SWIG_IsOK(res1)) {
12282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12283 }
12284 arg1 = reinterpret_cast< wxGrid * >(argp1);
12285 ecode2 = SWIG_AsVal_int(obj1, &val2);
12286 if (!SWIG_IsOK(ecode2)) {
12287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12288 }
12289 arg2 = static_cast< int >(val2);
12290 {
12291 PyThreadState* __tstate = wxPyBeginAllowThreads();
12292 result = (int)(arg1)->XToEdgeOfCol(arg2);
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 resultobj = SWIG_From_int(static_cast< int >(result));
12297 return resultobj;
12298 fail:
12299 return NULL;
12300 }
12301
12302
12303 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12304 PyObject *resultobj = 0;
12305 wxGrid *arg1 = (wxGrid *) 0 ;
12306 int arg2 ;
12307 int arg3 ;
12308 wxRect result;
12309 void *argp1 = 0 ;
12310 int res1 = 0 ;
12311 int val2 ;
12312 int ecode2 = 0 ;
12313 int val3 ;
12314 int ecode3 = 0 ;
12315 PyObject * obj0 = 0 ;
12316 PyObject * obj1 = 0 ;
12317 PyObject * obj2 = 0 ;
12318 char * kwnames[] = {
12319 (char *) "self",(char *) "row",(char *) "col", NULL
12320 };
12321
12322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12324 if (!SWIG_IsOK(res1)) {
12325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12326 }
12327 arg1 = reinterpret_cast< wxGrid * >(argp1);
12328 ecode2 = SWIG_AsVal_int(obj1, &val2);
12329 if (!SWIG_IsOK(ecode2)) {
12330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12331 }
12332 arg2 = static_cast< int >(val2);
12333 ecode3 = SWIG_AsVal_int(obj2, &val3);
12334 if (!SWIG_IsOK(ecode3)) {
12335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12336 }
12337 arg3 = static_cast< int >(val3);
12338 {
12339 PyThreadState* __tstate = wxPyBeginAllowThreads();
12340 result = (arg1)->CellToRect(arg2,arg3);
12341 wxPyEndAllowThreads(__tstate);
12342 if (PyErr_Occurred()) SWIG_fail;
12343 }
12344 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12352 PyObject *resultobj = 0;
12353 wxGrid *arg1 = (wxGrid *) 0 ;
12354 int result;
12355 void *argp1 = 0 ;
12356 int res1 = 0 ;
12357 PyObject *swig_obj[1] ;
12358
12359 if (!args) SWIG_fail;
12360 swig_obj[0] = args;
12361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12362 if (!SWIG_IsOK(res1)) {
12363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12364 }
12365 arg1 = reinterpret_cast< wxGrid * >(argp1);
12366 {
12367 PyThreadState* __tstate = wxPyBeginAllowThreads();
12368 result = (int)(arg1)->GetGridCursorRow();
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 resultobj = SWIG_From_int(static_cast< int >(result));
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12380 PyObject *resultobj = 0;
12381 wxGrid *arg1 = (wxGrid *) 0 ;
12382 int result;
12383 void *argp1 = 0 ;
12384 int res1 = 0 ;
12385 PyObject *swig_obj[1] ;
12386
12387 if (!args) SWIG_fail;
12388 swig_obj[0] = args;
12389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12390 if (!SWIG_IsOK(res1)) {
12391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12392 }
12393 arg1 = reinterpret_cast< wxGrid * >(argp1);
12394 {
12395 PyThreadState* __tstate = wxPyBeginAllowThreads();
12396 result = (int)(arg1)->GetGridCursorCol();
12397 wxPyEndAllowThreads(__tstate);
12398 if (PyErr_Occurred()) SWIG_fail;
12399 }
12400 resultobj = SWIG_From_int(static_cast< int >(result));
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj = 0;
12409 wxGrid *arg1 = (wxGrid *) 0 ;
12410 int arg2 ;
12411 int arg3 ;
12412 bool arg4 = (bool) true ;
12413 bool result;
12414 void *argp1 = 0 ;
12415 int res1 = 0 ;
12416 int val2 ;
12417 int ecode2 = 0 ;
12418 int val3 ;
12419 int ecode3 = 0 ;
12420 bool val4 ;
12421 int ecode4 = 0 ;
12422 PyObject * obj0 = 0 ;
12423 PyObject * obj1 = 0 ;
12424 PyObject * obj2 = 0 ;
12425 PyObject * obj3 = 0 ;
12426 char * kwnames[] = {
12427 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12428 };
12429
12430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12432 if (!SWIG_IsOK(res1)) {
12433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12434 }
12435 arg1 = reinterpret_cast< wxGrid * >(argp1);
12436 ecode2 = SWIG_AsVal_int(obj1, &val2);
12437 if (!SWIG_IsOK(ecode2)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12439 }
12440 arg2 = static_cast< int >(val2);
12441 ecode3 = SWIG_AsVal_int(obj2, &val3);
12442 if (!SWIG_IsOK(ecode3)) {
12443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12444 }
12445 arg3 = static_cast< int >(val3);
12446 if (obj3) {
12447 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12448 if (!SWIG_IsOK(ecode4)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12450 }
12451 arg4 = static_cast< bool >(val4);
12452 }
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 {
12460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12461 }
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj = 0;
12470 wxGrid *arg1 = (wxGrid *) 0 ;
12471 int arg2 ;
12472 int arg3 ;
12473 void *argp1 = 0 ;
12474 int res1 = 0 ;
12475 int val2 ;
12476 int ecode2 = 0 ;
12477 int val3 ;
12478 int ecode3 = 0 ;
12479 PyObject * obj0 = 0 ;
12480 PyObject * obj1 = 0 ;
12481 PyObject * obj2 = 0 ;
12482 char * kwnames[] = {
12483 (char *) "self",(char *) "row",(char *) "col", NULL
12484 };
12485
12486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12488 if (!SWIG_IsOK(res1)) {
12489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12490 }
12491 arg1 = reinterpret_cast< wxGrid * >(argp1);
12492 ecode2 = SWIG_AsVal_int(obj1, &val2);
12493 if (!SWIG_IsOK(ecode2)) {
12494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12495 }
12496 arg2 = static_cast< int >(val2);
12497 ecode3 = SWIG_AsVal_int(obj2, &val3);
12498 if (!SWIG_IsOK(ecode3)) {
12499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12500 }
12501 arg3 = static_cast< int >(val3);
12502 {
12503 PyThreadState* __tstate = wxPyBeginAllowThreads();
12504 (arg1)->MakeCellVisible(arg2,arg3);
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 resultobj = SWIG_Py_Void();
12509 return resultobj;
12510 fail:
12511 return NULL;
12512 }
12513
12514
12515 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12516 PyObject *resultobj = 0;
12517 wxGrid *arg1 = (wxGrid *) 0 ;
12518 int arg2 ;
12519 int arg3 ;
12520 void *argp1 = 0 ;
12521 int res1 = 0 ;
12522 int val2 ;
12523 int ecode2 = 0 ;
12524 int val3 ;
12525 int ecode3 = 0 ;
12526 PyObject * obj0 = 0 ;
12527 PyObject * obj1 = 0 ;
12528 PyObject * obj2 = 0 ;
12529 char * kwnames[] = {
12530 (char *) "self",(char *) "row",(char *) "col", NULL
12531 };
12532
12533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12535 if (!SWIG_IsOK(res1)) {
12536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12537 }
12538 arg1 = reinterpret_cast< wxGrid * >(argp1);
12539 ecode2 = SWIG_AsVal_int(obj1, &val2);
12540 if (!SWIG_IsOK(ecode2)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12542 }
12543 arg2 = static_cast< int >(val2);
12544 ecode3 = SWIG_AsVal_int(obj2, &val3);
12545 if (!SWIG_IsOK(ecode3)) {
12546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12547 }
12548 arg3 = static_cast< int >(val3);
12549 {
12550 PyThreadState* __tstate = wxPyBeginAllowThreads();
12551 (arg1)->SetGridCursor(arg2,arg3);
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 resultobj = SWIG_Py_Void();
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj = 0;
12564 wxGrid *arg1 = (wxGrid *) 0 ;
12565 bool arg2 ;
12566 bool result;
12567 void *argp1 = 0 ;
12568 int res1 = 0 ;
12569 bool val2 ;
12570 int ecode2 = 0 ;
12571 PyObject * obj0 = 0 ;
12572 PyObject * obj1 = 0 ;
12573 char * kwnames[] = {
12574 (char *) "self",(char *) "expandSelection", NULL
12575 };
12576
12577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12579 if (!SWIG_IsOK(res1)) {
12580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12581 }
12582 arg1 = reinterpret_cast< wxGrid * >(argp1);
12583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12584 if (!SWIG_IsOK(ecode2)) {
12585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12586 }
12587 arg2 = static_cast< bool >(val2);
12588 {
12589 PyThreadState* __tstate = wxPyBeginAllowThreads();
12590 result = (bool)(arg1)->MoveCursorUp(arg2);
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 {
12595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12596 }
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12604 PyObject *resultobj = 0;
12605 wxGrid *arg1 = (wxGrid *) 0 ;
12606 bool arg2 ;
12607 bool result;
12608 void *argp1 = 0 ;
12609 int res1 = 0 ;
12610 bool val2 ;
12611 int ecode2 = 0 ;
12612 PyObject * obj0 = 0 ;
12613 PyObject * obj1 = 0 ;
12614 char * kwnames[] = {
12615 (char *) "self",(char *) "expandSelection", NULL
12616 };
12617
12618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12620 if (!SWIG_IsOK(res1)) {
12621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12622 }
12623 arg1 = reinterpret_cast< wxGrid * >(argp1);
12624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12625 if (!SWIG_IsOK(ecode2)) {
12626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12627 }
12628 arg2 = static_cast< bool >(val2);
12629 {
12630 PyThreadState* __tstate = wxPyBeginAllowThreads();
12631 result = (bool)(arg1)->MoveCursorDown(arg2);
12632 wxPyEndAllowThreads(__tstate);
12633 if (PyErr_Occurred()) SWIG_fail;
12634 }
12635 {
12636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12637 }
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj = 0;
12646 wxGrid *arg1 = (wxGrid *) 0 ;
12647 bool arg2 ;
12648 bool result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 bool val2 ;
12652 int ecode2 = 0 ;
12653 PyObject * obj0 = 0 ;
12654 PyObject * obj1 = 0 ;
12655 char * kwnames[] = {
12656 (char *) "self",(char *) "expandSelection", NULL
12657 };
12658
12659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12661 if (!SWIG_IsOK(res1)) {
12662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12663 }
12664 arg1 = reinterpret_cast< wxGrid * >(argp1);
12665 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12666 if (!SWIG_IsOK(ecode2)) {
12667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12668 }
12669 arg2 = static_cast< bool >(val2);
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 result = (bool)(arg1)->MoveCursorLeft(arg2);
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 {
12677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12678 }
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12686 PyObject *resultobj = 0;
12687 wxGrid *arg1 = (wxGrid *) 0 ;
12688 bool arg2 ;
12689 bool result;
12690 void *argp1 = 0 ;
12691 int res1 = 0 ;
12692 bool val2 ;
12693 int ecode2 = 0 ;
12694 PyObject * obj0 = 0 ;
12695 PyObject * obj1 = 0 ;
12696 char * kwnames[] = {
12697 (char *) "self",(char *) "expandSelection", NULL
12698 };
12699
12700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12702 if (!SWIG_IsOK(res1)) {
12703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12704 }
12705 arg1 = reinterpret_cast< wxGrid * >(argp1);
12706 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12707 if (!SWIG_IsOK(ecode2)) {
12708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12709 }
12710 arg2 = static_cast< bool >(val2);
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 result = (bool)(arg1)->MoveCursorRight(arg2);
12714 wxPyEndAllowThreads(__tstate);
12715 if (PyErr_Occurred()) SWIG_fail;
12716 }
12717 {
12718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12719 }
12720 return resultobj;
12721 fail:
12722 return NULL;
12723 }
12724
12725
12726 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12727 PyObject *resultobj = 0;
12728 wxGrid *arg1 = (wxGrid *) 0 ;
12729 bool result;
12730 void *argp1 = 0 ;
12731 int res1 = 0 ;
12732 PyObject *swig_obj[1] ;
12733
12734 if (!args) SWIG_fail;
12735 swig_obj[0] = args;
12736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12737 if (!SWIG_IsOK(res1)) {
12738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12739 }
12740 arg1 = reinterpret_cast< wxGrid * >(argp1);
12741 {
12742 PyThreadState* __tstate = wxPyBeginAllowThreads();
12743 result = (bool)(arg1)->MovePageDown();
12744 wxPyEndAllowThreads(__tstate);
12745 if (PyErr_Occurred()) SWIG_fail;
12746 }
12747 {
12748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12749 }
12750 return resultobj;
12751 fail:
12752 return NULL;
12753 }
12754
12755
12756 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12757 PyObject *resultobj = 0;
12758 wxGrid *arg1 = (wxGrid *) 0 ;
12759 bool result;
12760 void *argp1 = 0 ;
12761 int res1 = 0 ;
12762 PyObject *swig_obj[1] ;
12763
12764 if (!args) SWIG_fail;
12765 swig_obj[0] = args;
12766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12767 if (!SWIG_IsOK(res1)) {
12768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12769 }
12770 arg1 = reinterpret_cast< wxGrid * >(argp1);
12771 {
12772 PyThreadState* __tstate = wxPyBeginAllowThreads();
12773 result = (bool)(arg1)->MovePageUp();
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 {
12778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12779 }
12780 return resultobj;
12781 fail:
12782 return NULL;
12783 }
12784
12785
12786 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12787 PyObject *resultobj = 0;
12788 wxGrid *arg1 = (wxGrid *) 0 ;
12789 bool arg2 ;
12790 bool result;
12791 void *argp1 = 0 ;
12792 int res1 = 0 ;
12793 bool val2 ;
12794 int ecode2 = 0 ;
12795 PyObject * obj0 = 0 ;
12796 PyObject * obj1 = 0 ;
12797 char * kwnames[] = {
12798 (char *) "self",(char *) "expandSelection", NULL
12799 };
12800
12801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12803 if (!SWIG_IsOK(res1)) {
12804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12805 }
12806 arg1 = reinterpret_cast< wxGrid * >(argp1);
12807 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12808 if (!SWIG_IsOK(ecode2)) {
12809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12810 }
12811 arg2 = static_cast< bool >(val2);
12812 {
12813 PyThreadState* __tstate = wxPyBeginAllowThreads();
12814 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12815 wxPyEndAllowThreads(__tstate);
12816 if (PyErr_Occurred()) SWIG_fail;
12817 }
12818 {
12819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12820 }
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12828 PyObject *resultobj = 0;
12829 wxGrid *arg1 = (wxGrid *) 0 ;
12830 bool arg2 ;
12831 bool result;
12832 void *argp1 = 0 ;
12833 int res1 = 0 ;
12834 bool val2 ;
12835 int ecode2 = 0 ;
12836 PyObject * obj0 = 0 ;
12837 PyObject * obj1 = 0 ;
12838 char * kwnames[] = {
12839 (char *) "self",(char *) "expandSelection", NULL
12840 };
12841
12842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12844 if (!SWIG_IsOK(res1)) {
12845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12846 }
12847 arg1 = reinterpret_cast< wxGrid * >(argp1);
12848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12849 if (!SWIG_IsOK(ecode2)) {
12850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12851 }
12852 arg2 = static_cast< bool >(val2);
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12856 wxPyEndAllowThreads(__tstate);
12857 if (PyErr_Occurred()) SWIG_fail;
12858 }
12859 {
12860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12861 }
12862 return resultobj;
12863 fail:
12864 return NULL;
12865 }
12866
12867
12868 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12869 PyObject *resultobj = 0;
12870 wxGrid *arg1 = (wxGrid *) 0 ;
12871 bool arg2 ;
12872 bool result;
12873 void *argp1 = 0 ;
12874 int res1 = 0 ;
12875 bool val2 ;
12876 int ecode2 = 0 ;
12877 PyObject * obj0 = 0 ;
12878 PyObject * obj1 = 0 ;
12879 char * kwnames[] = {
12880 (char *) "self",(char *) "expandSelection", NULL
12881 };
12882
12883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12885 if (!SWIG_IsOK(res1)) {
12886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12887 }
12888 arg1 = reinterpret_cast< wxGrid * >(argp1);
12889 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12890 if (!SWIG_IsOK(ecode2)) {
12891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12892 }
12893 arg2 = static_cast< bool >(val2);
12894 {
12895 PyThreadState* __tstate = wxPyBeginAllowThreads();
12896 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12897 wxPyEndAllowThreads(__tstate);
12898 if (PyErr_Occurred()) SWIG_fail;
12899 }
12900 {
12901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12902 }
12903 return resultobj;
12904 fail:
12905 return NULL;
12906 }
12907
12908
12909 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12910 PyObject *resultobj = 0;
12911 wxGrid *arg1 = (wxGrid *) 0 ;
12912 bool arg2 ;
12913 bool result;
12914 void *argp1 = 0 ;
12915 int res1 = 0 ;
12916 bool val2 ;
12917 int ecode2 = 0 ;
12918 PyObject * obj0 = 0 ;
12919 PyObject * obj1 = 0 ;
12920 char * kwnames[] = {
12921 (char *) "self",(char *) "expandSelection", NULL
12922 };
12923
12924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12926 if (!SWIG_IsOK(res1)) {
12927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12928 }
12929 arg1 = reinterpret_cast< wxGrid * >(argp1);
12930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12931 if (!SWIG_IsOK(ecode2)) {
12932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12933 }
12934 arg2 = static_cast< bool >(val2);
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12938 wxPyEndAllowThreads(__tstate);
12939 if (PyErr_Occurred()) SWIG_fail;
12940 }
12941 {
12942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12943 }
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12951 PyObject *resultobj = 0;
12952 wxGrid *arg1 = (wxGrid *) 0 ;
12953 int result;
12954 void *argp1 = 0 ;
12955 int res1 = 0 ;
12956 PyObject *swig_obj[1] ;
12957
12958 if (!args) SWIG_fail;
12959 swig_obj[0] = args;
12960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12961 if (!SWIG_IsOK(res1)) {
12962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12963 }
12964 arg1 = reinterpret_cast< wxGrid * >(argp1);
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 result = (int)(arg1)->GetDefaultRowLabelSize();
12968 wxPyEndAllowThreads(__tstate);
12969 if (PyErr_Occurred()) SWIG_fail;
12970 }
12971 resultobj = SWIG_From_int(static_cast< int >(result));
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12979 PyObject *resultobj = 0;
12980 wxGrid *arg1 = (wxGrid *) 0 ;
12981 int result;
12982 void *argp1 = 0 ;
12983 int res1 = 0 ;
12984 PyObject *swig_obj[1] ;
12985
12986 if (!args) SWIG_fail;
12987 swig_obj[0] = args;
12988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12989 if (!SWIG_IsOK(res1)) {
12990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12991 }
12992 arg1 = reinterpret_cast< wxGrid * >(argp1);
12993 {
12994 PyThreadState* __tstate = wxPyBeginAllowThreads();
12995 result = (int)(arg1)->GetRowLabelSize();
12996 wxPyEndAllowThreads(__tstate);
12997 if (PyErr_Occurred()) SWIG_fail;
12998 }
12999 resultobj = SWIG_From_int(static_cast< int >(result));
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13007 PyObject *resultobj = 0;
13008 wxGrid *arg1 = (wxGrid *) 0 ;
13009 int result;
13010 void *argp1 = 0 ;
13011 int res1 = 0 ;
13012 PyObject *swig_obj[1] ;
13013
13014 if (!args) SWIG_fail;
13015 swig_obj[0] = args;
13016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13017 if (!SWIG_IsOK(res1)) {
13018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13019 }
13020 arg1 = reinterpret_cast< wxGrid * >(argp1);
13021 {
13022 PyThreadState* __tstate = wxPyBeginAllowThreads();
13023 result = (int)(arg1)->GetDefaultColLabelSize();
13024 wxPyEndAllowThreads(__tstate);
13025 if (PyErr_Occurred()) SWIG_fail;
13026 }
13027 resultobj = SWIG_From_int(static_cast< int >(result));
13028 return resultobj;
13029 fail:
13030 return NULL;
13031 }
13032
13033
13034 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13035 PyObject *resultobj = 0;
13036 wxGrid *arg1 = (wxGrid *) 0 ;
13037 int result;
13038 void *argp1 = 0 ;
13039 int res1 = 0 ;
13040 PyObject *swig_obj[1] ;
13041
13042 if (!args) SWIG_fail;
13043 swig_obj[0] = args;
13044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13045 if (!SWIG_IsOK(res1)) {
13046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13047 }
13048 arg1 = reinterpret_cast< wxGrid * >(argp1);
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 result = (int)(arg1)->GetColLabelSize();
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 resultobj = SWIG_From_int(static_cast< int >(result));
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13063 PyObject *resultobj = 0;
13064 wxGrid *arg1 = (wxGrid *) 0 ;
13065 wxColour result;
13066 void *argp1 = 0 ;
13067 int res1 = 0 ;
13068 PyObject *swig_obj[1] ;
13069
13070 if (!args) SWIG_fail;
13071 swig_obj[0] = args;
13072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13073 if (!SWIG_IsOK(res1)) {
13074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13075 }
13076 arg1 = reinterpret_cast< wxGrid * >(argp1);
13077 {
13078 PyThreadState* __tstate = wxPyBeginAllowThreads();
13079 result = (arg1)->GetLabelBackgroundColour();
13080 wxPyEndAllowThreads(__tstate);
13081 if (PyErr_Occurred()) SWIG_fail;
13082 }
13083 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13084 return resultobj;
13085 fail:
13086 return NULL;
13087 }
13088
13089
13090 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13091 PyObject *resultobj = 0;
13092 wxGrid *arg1 = (wxGrid *) 0 ;
13093 wxColour result;
13094 void *argp1 = 0 ;
13095 int res1 = 0 ;
13096 PyObject *swig_obj[1] ;
13097
13098 if (!args) SWIG_fail;
13099 swig_obj[0] = args;
13100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13101 if (!SWIG_IsOK(res1)) {
13102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13103 }
13104 arg1 = reinterpret_cast< wxGrid * >(argp1);
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 result = (arg1)->GetLabelTextColour();
13108 wxPyEndAllowThreads(__tstate);
13109 if (PyErr_Occurred()) SWIG_fail;
13110 }
13111 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13112 return resultobj;
13113 fail:
13114 return NULL;
13115 }
13116
13117
13118 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13119 PyObject *resultobj = 0;
13120 wxGrid *arg1 = (wxGrid *) 0 ;
13121 wxFont result;
13122 void *argp1 = 0 ;
13123 int res1 = 0 ;
13124 PyObject *swig_obj[1] ;
13125
13126 if (!args) SWIG_fail;
13127 swig_obj[0] = args;
13128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13129 if (!SWIG_IsOK(res1)) {
13130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13131 }
13132 arg1 = reinterpret_cast< wxGrid * >(argp1);
13133 {
13134 PyThreadState* __tstate = wxPyBeginAllowThreads();
13135 result = (arg1)->GetLabelFont();
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13140 return resultobj;
13141 fail:
13142 return NULL;
13143 }
13144
13145
13146 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13147 PyObject *resultobj = 0;
13148 wxGrid *arg1 = (wxGrid *) 0 ;
13149 int *arg2 = (int *) 0 ;
13150 int *arg3 = (int *) 0 ;
13151 void *argp1 = 0 ;
13152 int res1 = 0 ;
13153 int temp2 ;
13154 int res2 = SWIG_TMPOBJ ;
13155 int temp3 ;
13156 int res3 = SWIG_TMPOBJ ;
13157 PyObject *swig_obj[1] ;
13158
13159 arg2 = &temp2;
13160 arg3 = &temp3;
13161 if (!args) SWIG_fail;
13162 swig_obj[0] = args;
13163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13164 if (!SWIG_IsOK(res1)) {
13165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13166 }
13167 arg1 = reinterpret_cast< wxGrid * >(argp1);
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 (arg1)->GetRowLabelAlignment(arg2,arg3);
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 resultobj = SWIG_Py_Void();
13175 if (SWIG_IsTmpObj(res2)) {
13176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13177 } else {
13178 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13180 }
13181 if (SWIG_IsTmpObj(res3)) {
13182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13183 } else {
13184 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13186 }
13187 return resultobj;
13188 fail:
13189 return NULL;
13190 }
13191
13192
13193 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13194 PyObject *resultobj = 0;
13195 wxGrid *arg1 = (wxGrid *) 0 ;
13196 int *arg2 = (int *) 0 ;
13197 int *arg3 = (int *) 0 ;
13198 void *argp1 = 0 ;
13199 int res1 = 0 ;
13200 int temp2 ;
13201 int res2 = SWIG_TMPOBJ ;
13202 int temp3 ;
13203 int res3 = SWIG_TMPOBJ ;
13204 PyObject *swig_obj[1] ;
13205
13206 arg2 = &temp2;
13207 arg3 = &temp3;
13208 if (!args) SWIG_fail;
13209 swig_obj[0] = args;
13210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13211 if (!SWIG_IsOK(res1)) {
13212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13213 }
13214 arg1 = reinterpret_cast< wxGrid * >(argp1);
13215 {
13216 PyThreadState* __tstate = wxPyBeginAllowThreads();
13217 (arg1)->GetColLabelAlignment(arg2,arg3);
13218 wxPyEndAllowThreads(__tstate);
13219 if (PyErr_Occurred()) SWIG_fail;
13220 }
13221 resultobj = SWIG_Py_Void();
13222 if (SWIG_IsTmpObj(res2)) {
13223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13224 } else {
13225 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13227 }
13228 if (SWIG_IsTmpObj(res3)) {
13229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13230 } else {
13231 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13233 }
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13241 PyObject *resultobj = 0;
13242 wxGrid *arg1 = (wxGrid *) 0 ;
13243 int result;
13244 void *argp1 = 0 ;
13245 int res1 = 0 ;
13246 PyObject *swig_obj[1] ;
13247
13248 if (!args) SWIG_fail;
13249 swig_obj[0] = args;
13250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13251 if (!SWIG_IsOK(res1)) {
13252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13253 }
13254 arg1 = reinterpret_cast< wxGrid * >(argp1);
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 result = (int)(arg1)->GetColLabelTextOrientation();
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 resultobj = SWIG_From_int(static_cast< int >(result));
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13269 PyObject *resultobj = 0;
13270 wxGrid *arg1 = (wxGrid *) 0 ;
13271 int arg2 ;
13272 wxString result;
13273 void *argp1 = 0 ;
13274 int res1 = 0 ;
13275 int val2 ;
13276 int ecode2 = 0 ;
13277 PyObject * obj0 = 0 ;
13278 PyObject * obj1 = 0 ;
13279 char * kwnames[] = {
13280 (char *) "self",(char *) "row", NULL
13281 };
13282
13283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13285 if (!SWIG_IsOK(res1)) {
13286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13287 }
13288 arg1 = reinterpret_cast< wxGrid * >(argp1);
13289 ecode2 = SWIG_AsVal_int(obj1, &val2);
13290 if (!SWIG_IsOK(ecode2)) {
13291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13292 }
13293 arg2 = static_cast< int >(val2);
13294 {
13295 PyThreadState* __tstate = wxPyBeginAllowThreads();
13296 result = (arg1)->GetRowLabelValue(arg2);
13297 wxPyEndAllowThreads(__tstate);
13298 if (PyErr_Occurred()) SWIG_fail;
13299 }
13300 {
13301 #if wxUSE_UNICODE
13302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13303 #else
13304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13305 #endif
13306 }
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13314 PyObject *resultobj = 0;
13315 wxGrid *arg1 = (wxGrid *) 0 ;
13316 int arg2 ;
13317 wxString result;
13318 void *argp1 = 0 ;
13319 int res1 = 0 ;
13320 int val2 ;
13321 int ecode2 = 0 ;
13322 PyObject * obj0 = 0 ;
13323 PyObject * obj1 = 0 ;
13324 char * kwnames[] = {
13325 (char *) "self",(char *) "col", NULL
13326 };
13327
13328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13330 if (!SWIG_IsOK(res1)) {
13331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13332 }
13333 arg1 = reinterpret_cast< wxGrid * >(argp1);
13334 ecode2 = SWIG_AsVal_int(obj1, &val2);
13335 if (!SWIG_IsOK(ecode2)) {
13336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13337 }
13338 arg2 = static_cast< int >(val2);
13339 {
13340 PyThreadState* __tstate = wxPyBeginAllowThreads();
13341 result = (arg1)->GetColLabelValue(arg2);
13342 wxPyEndAllowThreads(__tstate);
13343 if (PyErr_Occurred()) SWIG_fail;
13344 }
13345 {
13346 #if wxUSE_UNICODE
13347 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13348 #else
13349 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13350 #endif
13351 }
13352 return resultobj;
13353 fail:
13354 return NULL;
13355 }
13356
13357
13358 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13359 PyObject *resultobj = 0;
13360 wxGrid *arg1 = (wxGrid *) 0 ;
13361 wxColour result;
13362 void *argp1 = 0 ;
13363 int res1 = 0 ;
13364 PyObject *swig_obj[1] ;
13365
13366 if (!args) SWIG_fail;
13367 swig_obj[0] = args;
13368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13369 if (!SWIG_IsOK(res1)) {
13370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13371 }
13372 arg1 = reinterpret_cast< wxGrid * >(argp1);
13373 {
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 result = (arg1)->GetGridLineColour();
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13380 return resultobj;
13381 fail:
13382 return NULL;
13383 }
13384
13385
13386 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13387 PyObject *resultobj = 0;
13388 wxGrid *arg1 = (wxGrid *) 0 ;
13389 wxPen result;
13390 void *argp1 = 0 ;
13391 int res1 = 0 ;
13392 PyObject *swig_obj[1] ;
13393
13394 if (!args) SWIG_fail;
13395 swig_obj[0] = args;
13396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13397 if (!SWIG_IsOK(res1)) {
13398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13399 }
13400 arg1 = reinterpret_cast< wxGrid * >(argp1);
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 result = (arg1)->GetDefaultGridLinePen();
13404 wxPyEndAllowThreads(__tstate);
13405 if (PyErr_Occurred()) SWIG_fail;
13406 }
13407 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13408 return resultobj;
13409 fail:
13410 return NULL;
13411 }
13412
13413
13414 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13415 PyObject *resultobj = 0;
13416 wxGrid *arg1 = (wxGrid *) 0 ;
13417 int arg2 ;
13418 wxPen result;
13419 void *argp1 = 0 ;
13420 int res1 = 0 ;
13421 int val2 ;
13422 int ecode2 = 0 ;
13423 PyObject * obj0 = 0 ;
13424 PyObject * obj1 = 0 ;
13425 char * kwnames[] = {
13426 (char *) "self",(char *) "row", NULL
13427 };
13428
13429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",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_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13433 }
13434 arg1 = reinterpret_cast< wxGrid * >(argp1);
13435 ecode2 = SWIG_AsVal_int(obj1, &val2);
13436 if (!SWIG_IsOK(ecode2)) {
13437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13438 }
13439 arg2 = static_cast< int >(val2);
13440 {
13441 PyThreadState* __tstate = wxPyBeginAllowThreads();
13442 result = (arg1)->GetRowGridLinePen(arg2);
13443 wxPyEndAllowThreads(__tstate);
13444 if (PyErr_Occurred()) SWIG_fail;
13445 }
13446 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13447 return resultobj;
13448 fail:
13449 return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj = 0;
13455 wxGrid *arg1 = (wxGrid *) 0 ;
13456 int arg2 ;
13457 wxPen result;
13458 void *argp1 = 0 ;
13459 int res1 = 0 ;
13460 int val2 ;
13461 int ecode2 = 0 ;
13462 PyObject * obj0 = 0 ;
13463 PyObject * obj1 = 0 ;
13464 char * kwnames[] = {
13465 (char *) "self",(char *) "col", NULL
13466 };
13467
13468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13470 if (!SWIG_IsOK(res1)) {
13471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13472 }
13473 arg1 = reinterpret_cast< wxGrid * >(argp1);
13474 ecode2 = SWIG_AsVal_int(obj1, &val2);
13475 if (!SWIG_IsOK(ecode2)) {
13476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13477 }
13478 arg2 = static_cast< int >(val2);
13479 {
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 result = (arg1)->GetColGridLinePen(arg2);
13482 wxPyEndAllowThreads(__tstate);
13483 if (PyErr_Occurred()) SWIG_fail;
13484 }
13485 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13486 return resultobj;
13487 fail:
13488 return NULL;
13489 }
13490
13491
13492 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13493 PyObject *resultobj = 0;
13494 wxGrid *arg1 = (wxGrid *) 0 ;
13495 wxColour result;
13496 void *argp1 = 0 ;
13497 int res1 = 0 ;
13498 PyObject *swig_obj[1] ;
13499
13500 if (!args) SWIG_fail;
13501 swig_obj[0] = args;
13502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13503 if (!SWIG_IsOK(res1)) {
13504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13505 }
13506 arg1 = reinterpret_cast< wxGrid * >(argp1);
13507 {
13508 PyThreadState* __tstate = wxPyBeginAllowThreads();
13509 result = (arg1)->GetCellHighlightColour();
13510 wxPyEndAllowThreads(__tstate);
13511 if (PyErr_Occurred()) SWIG_fail;
13512 }
13513 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13514 return resultobj;
13515 fail:
13516 return NULL;
13517 }
13518
13519
13520 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13521 PyObject *resultobj = 0;
13522 wxGrid *arg1 = (wxGrid *) 0 ;
13523 int result;
13524 void *argp1 = 0 ;
13525 int res1 = 0 ;
13526 PyObject *swig_obj[1] ;
13527
13528 if (!args) SWIG_fail;
13529 swig_obj[0] = args;
13530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13531 if (!SWIG_IsOK(res1)) {
13532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13533 }
13534 arg1 = reinterpret_cast< wxGrid * >(argp1);
13535 {
13536 PyThreadState* __tstate = wxPyBeginAllowThreads();
13537 result = (int)(arg1)->GetCellHighlightPenWidth();
13538 wxPyEndAllowThreads(__tstate);
13539 if (PyErr_Occurred()) SWIG_fail;
13540 }
13541 resultobj = SWIG_From_int(static_cast< int >(result));
13542 return resultobj;
13543 fail:
13544 return NULL;
13545 }
13546
13547
13548 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13549 PyObject *resultobj = 0;
13550 wxGrid *arg1 = (wxGrid *) 0 ;
13551 int result;
13552 void *argp1 = 0 ;
13553 int res1 = 0 ;
13554 PyObject *swig_obj[1] ;
13555
13556 if (!args) SWIG_fail;
13557 swig_obj[0] = args;
13558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13559 if (!SWIG_IsOK(res1)) {
13560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13561 }
13562 arg1 = reinterpret_cast< wxGrid * >(argp1);
13563 {
13564 PyThreadState* __tstate = wxPyBeginAllowThreads();
13565 result = (int)(arg1)->GetCellHighlightROPenWidth();
13566 wxPyEndAllowThreads(__tstate);
13567 if (PyErr_Occurred()) SWIG_fail;
13568 }
13569 resultobj = SWIG_From_int(static_cast< int >(result));
13570 return resultobj;
13571 fail:
13572 return NULL;
13573 }
13574
13575
13576 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13577 PyObject *resultobj = 0;
13578 wxGrid *arg1 = (wxGrid *) 0 ;
13579 int arg2 ;
13580 void *argp1 = 0 ;
13581 int res1 = 0 ;
13582 int val2 ;
13583 int ecode2 = 0 ;
13584 PyObject * obj0 = 0 ;
13585 PyObject * obj1 = 0 ;
13586 char * kwnames[] = {
13587 (char *) "self",(char *) "width", NULL
13588 };
13589
13590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13592 if (!SWIG_IsOK(res1)) {
13593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13594 }
13595 arg1 = reinterpret_cast< wxGrid * >(argp1);
13596 ecode2 = SWIG_AsVal_int(obj1, &val2);
13597 if (!SWIG_IsOK(ecode2)) {
13598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13599 }
13600 arg2 = static_cast< int >(val2);
13601 {
13602 PyThreadState* __tstate = wxPyBeginAllowThreads();
13603 (arg1)->SetRowLabelSize(arg2);
13604 wxPyEndAllowThreads(__tstate);
13605 if (PyErr_Occurred()) SWIG_fail;
13606 }
13607 resultobj = SWIG_Py_Void();
13608 return resultobj;
13609 fail:
13610 return NULL;
13611 }
13612
13613
13614 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13615 PyObject *resultobj = 0;
13616 wxGrid *arg1 = (wxGrid *) 0 ;
13617 int arg2 ;
13618 void *argp1 = 0 ;
13619 int res1 = 0 ;
13620 int val2 ;
13621 int ecode2 = 0 ;
13622 PyObject * obj0 = 0 ;
13623 PyObject * obj1 = 0 ;
13624 char * kwnames[] = {
13625 (char *) "self",(char *) "height", NULL
13626 };
13627
13628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13630 if (!SWIG_IsOK(res1)) {
13631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13632 }
13633 arg1 = reinterpret_cast< wxGrid * >(argp1);
13634 ecode2 = SWIG_AsVal_int(obj1, &val2);
13635 if (!SWIG_IsOK(ecode2)) {
13636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13637 }
13638 arg2 = static_cast< int >(val2);
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 (arg1)->SetColLabelSize(arg2);
13642 wxPyEndAllowThreads(__tstate);
13643 if (PyErr_Occurred()) SWIG_fail;
13644 }
13645 resultobj = SWIG_Py_Void();
13646 return resultobj;
13647 fail:
13648 return NULL;
13649 }
13650
13651
13652 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13653 PyObject *resultobj = 0;
13654 wxGrid *arg1 = (wxGrid *) 0 ;
13655 wxColour *arg2 = 0 ;
13656 void *argp1 = 0 ;
13657 int res1 = 0 ;
13658 wxColour temp2 ;
13659 PyObject * obj0 = 0 ;
13660 PyObject * obj1 = 0 ;
13661 char * kwnames[] = {
13662 (char *) "self",(char *)"arg2", NULL
13663 };
13664
13665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13667 if (!SWIG_IsOK(res1)) {
13668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13669 }
13670 arg1 = reinterpret_cast< wxGrid * >(argp1);
13671 {
13672 arg2 = &temp2;
13673 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13674 }
13675 {
13676 PyThreadState* __tstate = wxPyBeginAllowThreads();
13677 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13678 wxPyEndAllowThreads(__tstate);
13679 if (PyErr_Occurred()) SWIG_fail;
13680 }
13681 resultobj = SWIG_Py_Void();
13682 return resultobj;
13683 fail:
13684 return NULL;
13685 }
13686
13687
13688 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13689 PyObject *resultobj = 0;
13690 wxGrid *arg1 = (wxGrid *) 0 ;
13691 wxColour *arg2 = 0 ;
13692 void *argp1 = 0 ;
13693 int res1 = 0 ;
13694 wxColour temp2 ;
13695 PyObject * obj0 = 0 ;
13696 PyObject * obj1 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *)"arg2", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13705 }
13706 arg1 = reinterpret_cast< wxGrid * >(argp1);
13707 {
13708 arg2 = &temp2;
13709 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13710 }
13711 {
13712 PyThreadState* __tstate = wxPyBeginAllowThreads();
13713 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13714 wxPyEndAllowThreads(__tstate);
13715 if (PyErr_Occurred()) SWIG_fail;
13716 }
13717 resultobj = SWIG_Py_Void();
13718 return resultobj;
13719 fail:
13720 return NULL;
13721 }
13722
13723
13724 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13725 PyObject *resultobj = 0;
13726 wxGrid *arg1 = (wxGrid *) 0 ;
13727 wxFont *arg2 = 0 ;
13728 void *argp1 = 0 ;
13729 int res1 = 0 ;
13730 void *argp2 = 0 ;
13731 int res2 = 0 ;
13732 PyObject * obj0 = 0 ;
13733 PyObject * obj1 = 0 ;
13734 char * kwnames[] = {
13735 (char *) "self",(char *)"arg2", NULL
13736 };
13737
13738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13740 if (!SWIG_IsOK(res1)) {
13741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13742 }
13743 arg1 = reinterpret_cast< wxGrid * >(argp1);
13744 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13745 if (!SWIG_IsOK(res2)) {
13746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13747 }
13748 if (!argp2) {
13749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13750 }
13751 arg2 = reinterpret_cast< wxFont * >(argp2);
13752 {
13753 PyThreadState* __tstate = wxPyBeginAllowThreads();
13754 (arg1)->SetLabelFont((wxFont const &)*arg2);
13755 wxPyEndAllowThreads(__tstate);
13756 if (PyErr_Occurred()) SWIG_fail;
13757 }
13758 resultobj = SWIG_Py_Void();
13759 return resultobj;
13760 fail:
13761 return NULL;
13762 }
13763
13764
13765 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13766 PyObject *resultobj = 0;
13767 wxGrid *arg1 = (wxGrid *) 0 ;
13768 int arg2 ;
13769 int arg3 ;
13770 void *argp1 = 0 ;
13771 int res1 = 0 ;
13772 int val2 ;
13773 int ecode2 = 0 ;
13774 int val3 ;
13775 int ecode3 = 0 ;
13776 PyObject * obj0 = 0 ;
13777 PyObject * obj1 = 0 ;
13778 PyObject * obj2 = 0 ;
13779 char * kwnames[] = {
13780 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13781 };
13782
13783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13787 }
13788 arg1 = reinterpret_cast< wxGrid * >(argp1);
13789 ecode2 = SWIG_AsVal_int(obj1, &val2);
13790 if (!SWIG_IsOK(ecode2)) {
13791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13792 }
13793 arg2 = static_cast< int >(val2);
13794 ecode3 = SWIG_AsVal_int(obj2, &val3);
13795 if (!SWIG_IsOK(ecode3)) {
13796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13797 }
13798 arg3 = static_cast< int >(val3);
13799 {
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 (arg1)->SetRowLabelAlignment(arg2,arg3);
13802 wxPyEndAllowThreads(__tstate);
13803 if (PyErr_Occurred()) SWIG_fail;
13804 }
13805 resultobj = SWIG_Py_Void();
13806 return resultobj;
13807 fail:
13808 return NULL;
13809 }
13810
13811
13812 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13813 PyObject *resultobj = 0;
13814 wxGrid *arg1 = (wxGrid *) 0 ;
13815 int arg2 ;
13816 int arg3 ;
13817 void *argp1 = 0 ;
13818 int res1 = 0 ;
13819 int val2 ;
13820 int ecode2 = 0 ;
13821 int val3 ;
13822 int ecode3 = 0 ;
13823 PyObject * obj0 = 0 ;
13824 PyObject * obj1 = 0 ;
13825 PyObject * obj2 = 0 ;
13826 char * kwnames[] = {
13827 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13828 };
13829
13830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13832 if (!SWIG_IsOK(res1)) {
13833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13834 }
13835 arg1 = reinterpret_cast< wxGrid * >(argp1);
13836 ecode2 = SWIG_AsVal_int(obj1, &val2);
13837 if (!SWIG_IsOK(ecode2)) {
13838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13839 }
13840 arg2 = static_cast< int >(val2);
13841 ecode3 = SWIG_AsVal_int(obj2, &val3);
13842 if (!SWIG_IsOK(ecode3)) {
13843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13844 }
13845 arg3 = static_cast< int >(val3);
13846 {
13847 PyThreadState* __tstate = wxPyBeginAllowThreads();
13848 (arg1)->SetColLabelAlignment(arg2,arg3);
13849 wxPyEndAllowThreads(__tstate);
13850 if (PyErr_Occurred()) SWIG_fail;
13851 }
13852 resultobj = SWIG_Py_Void();
13853 return resultobj;
13854 fail:
13855 return NULL;
13856 }
13857
13858
13859 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13860 PyObject *resultobj = 0;
13861 wxGrid *arg1 = (wxGrid *) 0 ;
13862 int arg2 ;
13863 void *argp1 = 0 ;
13864 int res1 = 0 ;
13865 int val2 ;
13866 int ecode2 = 0 ;
13867 PyObject * obj0 = 0 ;
13868 PyObject * obj1 = 0 ;
13869 char * kwnames[] = {
13870 (char *) "self",(char *) "textOrientation", NULL
13871 };
13872
13873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13875 if (!SWIG_IsOK(res1)) {
13876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13877 }
13878 arg1 = reinterpret_cast< wxGrid * >(argp1);
13879 ecode2 = SWIG_AsVal_int(obj1, &val2);
13880 if (!SWIG_IsOK(ecode2)) {
13881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13882 }
13883 arg2 = static_cast< int >(val2);
13884 {
13885 PyThreadState* __tstate = wxPyBeginAllowThreads();
13886 (arg1)->SetColLabelTextOrientation(arg2);
13887 wxPyEndAllowThreads(__tstate);
13888 if (PyErr_Occurred()) SWIG_fail;
13889 }
13890 resultobj = SWIG_Py_Void();
13891 return resultobj;
13892 fail:
13893 return NULL;
13894 }
13895
13896
13897 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13898 PyObject *resultobj = 0;
13899 wxGrid *arg1 = (wxGrid *) 0 ;
13900 int arg2 ;
13901 wxString *arg3 = 0 ;
13902 void *argp1 = 0 ;
13903 int res1 = 0 ;
13904 int val2 ;
13905 int ecode2 = 0 ;
13906 bool temp3 = false ;
13907 PyObject * obj0 = 0 ;
13908 PyObject * obj1 = 0 ;
13909 PyObject * obj2 = 0 ;
13910 char * kwnames[] = {
13911 (char *) "self",(char *) "row",(char *)"arg3", NULL
13912 };
13913
13914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13916 if (!SWIG_IsOK(res1)) {
13917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13918 }
13919 arg1 = reinterpret_cast< wxGrid * >(argp1);
13920 ecode2 = SWIG_AsVal_int(obj1, &val2);
13921 if (!SWIG_IsOK(ecode2)) {
13922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13923 }
13924 arg2 = static_cast< int >(val2);
13925 {
13926 arg3 = wxString_in_helper(obj2);
13927 if (arg3 == NULL) SWIG_fail;
13928 temp3 = true;
13929 }
13930 {
13931 PyThreadState* __tstate = wxPyBeginAllowThreads();
13932 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13933 wxPyEndAllowThreads(__tstate);
13934 if (PyErr_Occurred()) SWIG_fail;
13935 }
13936 resultobj = SWIG_Py_Void();
13937 {
13938 if (temp3)
13939 delete arg3;
13940 }
13941 return resultobj;
13942 fail:
13943 {
13944 if (temp3)
13945 delete arg3;
13946 }
13947 return NULL;
13948 }
13949
13950
13951 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13952 PyObject *resultobj = 0;
13953 wxGrid *arg1 = (wxGrid *) 0 ;
13954 int arg2 ;
13955 wxString *arg3 = 0 ;
13956 void *argp1 = 0 ;
13957 int res1 = 0 ;
13958 int val2 ;
13959 int ecode2 = 0 ;
13960 bool temp3 = false ;
13961 PyObject * obj0 = 0 ;
13962 PyObject * obj1 = 0 ;
13963 PyObject * obj2 = 0 ;
13964 char * kwnames[] = {
13965 (char *) "self",(char *) "col",(char *)"arg3", NULL
13966 };
13967
13968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13970 if (!SWIG_IsOK(res1)) {
13971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13972 }
13973 arg1 = reinterpret_cast< wxGrid * >(argp1);
13974 ecode2 = SWIG_AsVal_int(obj1, &val2);
13975 if (!SWIG_IsOK(ecode2)) {
13976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13977 }
13978 arg2 = static_cast< int >(val2);
13979 {
13980 arg3 = wxString_in_helper(obj2);
13981 if (arg3 == NULL) SWIG_fail;
13982 temp3 = true;
13983 }
13984 {
13985 PyThreadState* __tstate = wxPyBeginAllowThreads();
13986 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 resultobj = SWIG_Py_Void();
13991 {
13992 if (temp3)
13993 delete arg3;
13994 }
13995 return resultobj;
13996 fail:
13997 {
13998 if (temp3)
13999 delete arg3;
14000 }
14001 return NULL;
14002 }
14003
14004
14005 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14006 PyObject *resultobj = 0;
14007 wxGrid *arg1 = (wxGrid *) 0 ;
14008 wxColour *arg2 = 0 ;
14009 void *argp1 = 0 ;
14010 int res1 = 0 ;
14011 wxColour temp2 ;
14012 PyObject * obj0 = 0 ;
14013 PyObject * obj1 = 0 ;
14014 char * kwnames[] = {
14015 (char *) "self",(char *)"arg2", NULL
14016 };
14017
14018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
14019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14020 if (!SWIG_IsOK(res1)) {
14021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14022 }
14023 arg1 = reinterpret_cast< wxGrid * >(argp1);
14024 {
14025 arg2 = &temp2;
14026 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14027 }
14028 {
14029 PyThreadState* __tstate = wxPyBeginAllowThreads();
14030 (arg1)->SetGridLineColour((wxColour const &)*arg2);
14031 wxPyEndAllowThreads(__tstate);
14032 if (PyErr_Occurred()) SWIG_fail;
14033 }
14034 resultobj = SWIG_Py_Void();
14035 return resultobj;
14036 fail:
14037 return NULL;
14038 }
14039
14040
14041 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj = 0;
14043 wxGrid *arg1 = (wxGrid *) 0 ;
14044 wxColour *arg2 = 0 ;
14045 void *argp1 = 0 ;
14046 int res1 = 0 ;
14047 wxColour temp2 ;
14048 PyObject * obj0 = 0 ;
14049 PyObject * obj1 = 0 ;
14050 char * kwnames[] = {
14051 (char *) "self",(char *)"arg2", NULL
14052 };
14053
14054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
14055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14056 if (!SWIG_IsOK(res1)) {
14057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14058 }
14059 arg1 = reinterpret_cast< wxGrid * >(argp1);
14060 {
14061 arg2 = &temp2;
14062 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14063 }
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 resultobj = SWIG_Py_Void();
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj = 0;
14079 wxGrid *arg1 = (wxGrid *) 0 ;
14080 int arg2 ;
14081 void *argp1 = 0 ;
14082 int res1 = 0 ;
14083 int val2 ;
14084 int ecode2 = 0 ;
14085 PyObject * obj0 = 0 ;
14086 PyObject * obj1 = 0 ;
14087 char * kwnames[] = {
14088 (char *) "self",(char *) "width", NULL
14089 };
14090
14091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14093 if (!SWIG_IsOK(res1)) {
14094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14095 }
14096 arg1 = reinterpret_cast< wxGrid * >(argp1);
14097 ecode2 = SWIG_AsVal_int(obj1, &val2);
14098 if (!SWIG_IsOK(ecode2)) {
14099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
14100 }
14101 arg2 = static_cast< int >(val2);
14102 {
14103 PyThreadState* __tstate = wxPyBeginAllowThreads();
14104 (arg1)->SetCellHighlightPenWidth(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_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14116 PyObject *resultobj = 0;
14117 wxGrid *arg1 = (wxGrid *) 0 ;
14118 int arg2 ;
14119 void *argp1 = 0 ;
14120 int res1 = 0 ;
14121 int val2 ;
14122 int ecode2 = 0 ;
14123 PyObject * obj0 = 0 ;
14124 PyObject * obj1 = 0 ;
14125 char * kwnames[] = {
14126 (char *) "self",(char *) "width", NULL
14127 };
14128
14129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14131 if (!SWIG_IsOK(res1)) {
14132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14133 }
14134 arg1 = reinterpret_cast< wxGrid * >(argp1);
14135 ecode2 = SWIG_AsVal_int(obj1, &val2);
14136 if (!SWIG_IsOK(ecode2)) {
14137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
14138 }
14139 arg2 = static_cast< int >(val2);
14140 {
14141 PyThreadState* __tstate = wxPyBeginAllowThreads();
14142 (arg1)->SetCellHighlightROPenWidth(arg2);
14143 wxPyEndAllowThreads(__tstate);
14144 if (PyErr_Occurred()) SWIG_fail;
14145 }
14146 resultobj = SWIG_Py_Void();
14147 return resultobj;
14148 fail:
14149 return NULL;
14150 }
14151
14152
14153 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14154 PyObject *resultobj = 0;
14155 wxGrid *arg1 = (wxGrid *) 0 ;
14156 bool arg2 = (bool) true ;
14157 void *argp1 = 0 ;
14158 int res1 = 0 ;
14159 bool val2 ;
14160 int ecode2 = 0 ;
14161 PyObject * obj0 = 0 ;
14162 PyObject * obj1 = 0 ;
14163 char * kwnames[] = {
14164 (char *) "self",(char *) "enable", NULL
14165 };
14166
14167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14169 if (!SWIG_IsOK(res1)) {
14170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14171 }
14172 arg1 = reinterpret_cast< wxGrid * >(argp1);
14173 if (obj1) {
14174 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14175 if (!SWIG_IsOK(ecode2)) {
14176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14177 }
14178 arg2 = static_cast< bool >(val2);
14179 }
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 (arg1)->EnableDragRowSize(arg2);
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 resultobj = SWIG_Py_Void();
14187 return resultobj;
14188 fail:
14189 return NULL;
14190 }
14191
14192
14193 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14194 PyObject *resultobj = 0;
14195 wxGrid *arg1 = (wxGrid *) 0 ;
14196 void *argp1 = 0 ;
14197 int res1 = 0 ;
14198 PyObject *swig_obj[1] ;
14199
14200 if (!args) SWIG_fail;
14201 swig_obj[0] = args;
14202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14203 if (!SWIG_IsOK(res1)) {
14204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14205 }
14206 arg1 = reinterpret_cast< wxGrid * >(argp1);
14207 {
14208 PyThreadState* __tstate = wxPyBeginAllowThreads();
14209 (arg1)->DisableDragRowSize();
14210 wxPyEndAllowThreads(__tstate);
14211 if (PyErr_Occurred()) SWIG_fail;
14212 }
14213 resultobj = SWIG_Py_Void();
14214 return resultobj;
14215 fail:
14216 return NULL;
14217 }
14218
14219
14220 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14221 PyObject *resultobj = 0;
14222 wxGrid *arg1 = (wxGrid *) 0 ;
14223 bool result;
14224 void *argp1 = 0 ;
14225 int res1 = 0 ;
14226 PyObject *swig_obj[1] ;
14227
14228 if (!args) SWIG_fail;
14229 swig_obj[0] = args;
14230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14231 if (!SWIG_IsOK(res1)) {
14232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14233 }
14234 arg1 = reinterpret_cast< wxGrid * >(argp1);
14235 {
14236 PyThreadState* __tstate = wxPyBeginAllowThreads();
14237 result = (bool)(arg1)->CanDragRowSize();
14238 wxPyEndAllowThreads(__tstate);
14239 if (PyErr_Occurred()) SWIG_fail;
14240 }
14241 {
14242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14243 }
14244 return resultobj;
14245 fail:
14246 return NULL;
14247 }
14248
14249
14250 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14251 PyObject *resultobj = 0;
14252 wxGrid *arg1 = (wxGrid *) 0 ;
14253 bool arg2 = (bool) true ;
14254 void *argp1 = 0 ;
14255 int res1 = 0 ;
14256 bool val2 ;
14257 int ecode2 = 0 ;
14258 PyObject * obj0 = 0 ;
14259 PyObject * obj1 = 0 ;
14260 char * kwnames[] = {
14261 (char *) "self",(char *) "enable", NULL
14262 };
14263
14264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14266 if (!SWIG_IsOK(res1)) {
14267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14268 }
14269 arg1 = reinterpret_cast< wxGrid * >(argp1);
14270 if (obj1) {
14271 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14272 if (!SWIG_IsOK(ecode2)) {
14273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14274 }
14275 arg2 = static_cast< bool >(val2);
14276 }
14277 {
14278 PyThreadState* __tstate = wxPyBeginAllowThreads();
14279 (arg1)->EnableDragColSize(arg2);
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 resultobj = SWIG_Py_Void();
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14291 PyObject *resultobj = 0;
14292 wxGrid *arg1 = (wxGrid *) 0 ;
14293 void *argp1 = 0 ;
14294 int res1 = 0 ;
14295 PyObject *swig_obj[1] ;
14296
14297 if (!args) SWIG_fail;
14298 swig_obj[0] = args;
14299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14300 if (!SWIG_IsOK(res1)) {
14301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14302 }
14303 arg1 = reinterpret_cast< wxGrid * >(argp1);
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 (arg1)->DisableDragColSize();
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 resultobj = SWIG_Py_Void();
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14318 PyObject *resultobj = 0;
14319 wxGrid *arg1 = (wxGrid *) 0 ;
14320 bool result;
14321 void *argp1 = 0 ;
14322 int res1 = 0 ;
14323 PyObject *swig_obj[1] ;
14324
14325 if (!args) SWIG_fail;
14326 swig_obj[0] = args;
14327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14328 if (!SWIG_IsOK(res1)) {
14329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14330 }
14331 arg1 = reinterpret_cast< wxGrid * >(argp1);
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 result = (bool)(arg1)->CanDragColSize();
14335 wxPyEndAllowThreads(__tstate);
14336 if (PyErr_Occurred()) SWIG_fail;
14337 }
14338 {
14339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14340 }
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj = 0;
14349 wxGrid *arg1 = (wxGrid *) 0 ;
14350 bool arg2 = (bool) true ;
14351 void *argp1 = 0 ;
14352 int res1 = 0 ;
14353 bool val2 ;
14354 int ecode2 = 0 ;
14355 PyObject * obj0 = 0 ;
14356 PyObject * obj1 = 0 ;
14357 char * kwnames[] = {
14358 (char *) "self",(char *) "enable", NULL
14359 };
14360
14361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14363 if (!SWIG_IsOK(res1)) {
14364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14365 }
14366 arg1 = reinterpret_cast< wxGrid * >(argp1);
14367 if (obj1) {
14368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14369 if (!SWIG_IsOK(ecode2)) {
14370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14371 }
14372 arg2 = static_cast< bool >(val2);
14373 }
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 (arg1)->EnableDragColMove(arg2);
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 resultobj = SWIG_Py_Void();
14381 return resultobj;
14382 fail:
14383 return NULL;
14384 }
14385
14386
14387 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14388 PyObject *resultobj = 0;
14389 wxGrid *arg1 = (wxGrid *) 0 ;
14390 void *argp1 = 0 ;
14391 int res1 = 0 ;
14392 PyObject *swig_obj[1] ;
14393
14394 if (!args) SWIG_fail;
14395 swig_obj[0] = args;
14396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14397 if (!SWIG_IsOK(res1)) {
14398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14399 }
14400 arg1 = reinterpret_cast< wxGrid * >(argp1);
14401 {
14402 PyThreadState* __tstate = wxPyBeginAllowThreads();
14403 (arg1)->DisableDragColMove();
14404 wxPyEndAllowThreads(__tstate);
14405 if (PyErr_Occurred()) SWIG_fail;
14406 }
14407 resultobj = SWIG_Py_Void();
14408 return resultobj;
14409 fail:
14410 return NULL;
14411 }
14412
14413
14414 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14415 PyObject *resultobj = 0;
14416 wxGrid *arg1 = (wxGrid *) 0 ;
14417 bool result;
14418 void *argp1 = 0 ;
14419 int res1 = 0 ;
14420 PyObject *swig_obj[1] ;
14421
14422 if (!args) SWIG_fail;
14423 swig_obj[0] = args;
14424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14425 if (!SWIG_IsOK(res1)) {
14426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14427 }
14428 arg1 = reinterpret_cast< wxGrid * >(argp1);
14429 {
14430 PyThreadState* __tstate = wxPyBeginAllowThreads();
14431 result = (bool)(arg1)->CanDragColMove();
14432 wxPyEndAllowThreads(__tstate);
14433 if (PyErr_Occurred()) SWIG_fail;
14434 }
14435 {
14436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14437 }
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14445 PyObject *resultobj = 0;
14446 wxGrid *arg1 = (wxGrid *) 0 ;
14447 bool arg2 = (bool) true ;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 bool val2 ;
14451 int ecode2 = 0 ;
14452 PyObject * obj0 = 0 ;
14453 PyObject * obj1 = 0 ;
14454 char * kwnames[] = {
14455 (char *) "self",(char *) "enable", NULL
14456 };
14457
14458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14460 if (!SWIG_IsOK(res1)) {
14461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14462 }
14463 arg1 = reinterpret_cast< wxGrid * >(argp1);
14464 if (obj1) {
14465 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14466 if (!SWIG_IsOK(ecode2)) {
14467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14468 }
14469 arg2 = static_cast< bool >(val2);
14470 }
14471 {
14472 PyThreadState* __tstate = wxPyBeginAllowThreads();
14473 (arg1)->EnableDragGridSize(arg2);
14474 wxPyEndAllowThreads(__tstate);
14475 if (PyErr_Occurred()) SWIG_fail;
14476 }
14477 resultobj = SWIG_Py_Void();
14478 return resultobj;
14479 fail:
14480 return NULL;
14481 }
14482
14483
14484 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14485 PyObject *resultobj = 0;
14486 wxGrid *arg1 = (wxGrid *) 0 ;
14487 void *argp1 = 0 ;
14488 int res1 = 0 ;
14489 PyObject *swig_obj[1] ;
14490
14491 if (!args) SWIG_fail;
14492 swig_obj[0] = args;
14493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14494 if (!SWIG_IsOK(res1)) {
14495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14496 }
14497 arg1 = reinterpret_cast< wxGrid * >(argp1);
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 (arg1)->DisableDragGridSize();
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 resultobj = SWIG_Py_Void();
14505 return resultobj;
14506 fail:
14507 return NULL;
14508 }
14509
14510
14511 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14512 PyObject *resultobj = 0;
14513 wxGrid *arg1 = (wxGrid *) 0 ;
14514 bool result;
14515 void *argp1 = 0 ;
14516 int res1 = 0 ;
14517 PyObject *swig_obj[1] ;
14518
14519 if (!args) SWIG_fail;
14520 swig_obj[0] = args;
14521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14522 if (!SWIG_IsOK(res1)) {
14523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14524 }
14525 arg1 = reinterpret_cast< wxGrid * >(argp1);
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (bool)(arg1)->CanDragGridSize();
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 {
14533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14534 }
14535 return resultobj;
14536 fail:
14537 return NULL;
14538 }
14539
14540
14541 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14542 PyObject *resultobj = 0;
14543 wxGrid *arg1 = (wxGrid *) 0 ;
14544 bool arg2 = (bool) true ;
14545 void *argp1 = 0 ;
14546 int res1 = 0 ;
14547 bool val2 ;
14548 int ecode2 = 0 ;
14549 PyObject * obj0 = 0 ;
14550 PyObject * obj1 = 0 ;
14551 char * kwnames[] = {
14552 (char *) "self",(char *) "enable", NULL
14553 };
14554
14555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14557 if (!SWIG_IsOK(res1)) {
14558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14559 }
14560 arg1 = reinterpret_cast< wxGrid * >(argp1);
14561 if (obj1) {
14562 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14563 if (!SWIG_IsOK(ecode2)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14565 }
14566 arg2 = static_cast< bool >(val2);
14567 }
14568 {
14569 PyThreadState* __tstate = wxPyBeginAllowThreads();
14570 (arg1)->EnableDragCell(arg2);
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 resultobj = SWIG_Py_Void();
14575 return resultobj;
14576 fail:
14577 return NULL;
14578 }
14579
14580
14581 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14582 PyObject *resultobj = 0;
14583 wxGrid *arg1 = (wxGrid *) 0 ;
14584 void *argp1 = 0 ;
14585 int res1 = 0 ;
14586 PyObject *swig_obj[1] ;
14587
14588 if (!args) SWIG_fail;
14589 swig_obj[0] = args;
14590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14591 if (!SWIG_IsOK(res1)) {
14592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14593 }
14594 arg1 = reinterpret_cast< wxGrid * >(argp1);
14595 {
14596 PyThreadState* __tstate = wxPyBeginAllowThreads();
14597 (arg1)->DisableDragCell();
14598 wxPyEndAllowThreads(__tstate);
14599 if (PyErr_Occurred()) SWIG_fail;
14600 }
14601 resultobj = SWIG_Py_Void();
14602 return resultobj;
14603 fail:
14604 return NULL;
14605 }
14606
14607
14608 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14609 PyObject *resultobj = 0;
14610 wxGrid *arg1 = (wxGrid *) 0 ;
14611 bool result;
14612 void *argp1 = 0 ;
14613 int res1 = 0 ;
14614 PyObject *swig_obj[1] ;
14615
14616 if (!args) SWIG_fail;
14617 swig_obj[0] = args;
14618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14619 if (!SWIG_IsOK(res1)) {
14620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14621 }
14622 arg1 = reinterpret_cast< wxGrid * >(argp1);
14623 {
14624 PyThreadState* __tstate = wxPyBeginAllowThreads();
14625 result = (bool)(arg1)->CanDragCell();
14626 wxPyEndAllowThreads(__tstate);
14627 if (PyErr_Occurred()) SWIG_fail;
14628 }
14629 {
14630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14631 }
14632 return resultobj;
14633 fail:
14634 return NULL;
14635 }
14636
14637
14638 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14639 PyObject *resultobj = 0;
14640 wxGrid *arg1 = (wxGrid *) 0 ;
14641 int arg2 ;
14642 int arg3 ;
14643 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14644 void *argp1 = 0 ;
14645 int res1 = 0 ;
14646 int val2 ;
14647 int ecode2 = 0 ;
14648 int val3 ;
14649 int ecode3 = 0 ;
14650 void *argp4 = 0 ;
14651 int res4 = 0 ;
14652 PyObject * obj0 = 0 ;
14653 PyObject * obj1 = 0 ;
14654 PyObject * obj2 = 0 ;
14655 PyObject * obj3 = 0 ;
14656 char * kwnames[] = {
14657 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14658 };
14659
14660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14662 if (!SWIG_IsOK(res1)) {
14663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14664 }
14665 arg1 = reinterpret_cast< wxGrid * >(argp1);
14666 ecode2 = SWIG_AsVal_int(obj1, &val2);
14667 if (!SWIG_IsOK(ecode2)) {
14668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14669 }
14670 arg2 = static_cast< int >(val2);
14671 ecode3 = SWIG_AsVal_int(obj2, &val3);
14672 if (!SWIG_IsOK(ecode3)) {
14673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14674 }
14675 arg3 = static_cast< int >(val3);
14676 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14677 if (!SWIG_IsOK(res4)) {
14678 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14679 }
14680 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14681 {
14682 PyThreadState* __tstate = wxPyBeginAllowThreads();
14683 (arg1)->SetAttr(arg2,arg3,arg4);
14684 wxPyEndAllowThreads(__tstate);
14685 if (PyErr_Occurred()) SWIG_fail;
14686 }
14687 resultobj = SWIG_Py_Void();
14688 return resultobj;
14689 fail:
14690 return NULL;
14691 }
14692
14693
14694 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14695 PyObject *resultobj = 0;
14696 wxGrid *arg1 = (wxGrid *) 0 ;
14697 int arg2 ;
14698 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14699 void *argp1 = 0 ;
14700 int res1 = 0 ;
14701 int val2 ;
14702 int ecode2 = 0 ;
14703 void *argp3 = 0 ;
14704 int res3 = 0 ;
14705 PyObject * obj0 = 0 ;
14706 PyObject * obj1 = 0 ;
14707 PyObject * obj2 = 0 ;
14708 char * kwnames[] = {
14709 (char *) "self",(char *) "row",(char *) "attr", NULL
14710 };
14711
14712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14714 if (!SWIG_IsOK(res1)) {
14715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14716 }
14717 arg1 = reinterpret_cast< wxGrid * >(argp1);
14718 ecode2 = SWIG_AsVal_int(obj1, &val2);
14719 if (!SWIG_IsOK(ecode2)) {
14720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14721 }
14722 arg2 = static_cast< int >(val2);
14723 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14724 if (!SWIG_IsOK(res3)) {
14725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14726 }
14727 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14728 {
14729 PyThreadState* __tstate = wxPyBeginAllowThreads();
14730 (arg1)->SetRowAttr(arg2,arg3);
14731 wxPyEndAllowThreads(__tstate);
14732 if (PyErr_Occurred()) SWIG_fail;
14733 }
14734 resultobj = SWIG_Py_Void();
14735 return resultobj;
14736 fail:
14737 return NULL;
14738 }
14739
14740
14741 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14742 PyObject *resultobj = 0;
14743 wxGrid *arg1 = (wxGrid *) 0 ;
14744 int arg2 ;
14745 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14746 void *argp1 = 0 ;
14747 int res1 = 0 ;
14748 int val2 ;
14749 int ecode2 = 0 ;
14750 void *argp3 = 0 ;
14751 int res3 = 0 ;
14752 PyObject * obj0 = 0 ;
14753 PyObject * obj1 = 0 ;
14754 PyObject * obj2 = 0 ;
14755 char * kwnames[] = {
14756 (char *) "self",(char *) "col",(char *) "attr", NULL
14757 };
14758
14759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14761 if (!SWIG_IsOK(res1)) {
14762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14763 }
14764 arg1 = reinterpret_cast< wxGrid * >(argp1);
14765 ecode2 = SWIG_AsVal_int(obj1, &val2);
14766 if (!SWIG_IsOK(ecode2)) {
14767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14768 }
14769 arg2 = static_cast< int >(val2);
14770 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14771 if (!SWIG_IsOK(res3)) {
14772 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14773 }
14774 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 (arg1)->SetColAttr(arg2,arg3);
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 resultobj = SWIG_Py_Void();
14782 return resultobj;
14783 fail:
14784 return NULL;
14785 }
14786
14787
14788 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14789 PyObject *resultobj = 0;
14790 wxGrid *arg1 = (wxGrid *) 0 ;
14791 int arg2 ;
14792 int arg3 ;
14793 wxGridCellAttr *result = 0 ;
14794 void *argp1 = 0 ;
14795 int res1 = 0 ;
14796 int val2 ;
14797 int ecode2 = 0 ;
14798 int val3 ;
14799 int ecode3 = 0 ;
14800 PyObject * obj0 = 0 ;
14801 PyObject * obj1 = 0 ;
14802 PyObject * obj2 = 0 ;
14803 char * kwnames[] = {
14804 (char *) "self",(char *) "row",(char *) "col", NULL
14805 };
14806
14807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14809 if (!SWIG_IsOK(res1)) {
14810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14811 }
14812 arg1 = reinterpret_cast< wxGrid * >(argp1);
14813 ecode2 = SWIG_AsVal_int(obj1, &val2);
14814 if (!SWIG_IsOK(ecode2)) {
14815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14816 }
14817 arg2 = static_cast< int >(val2);
14818 ecode3 = SWIG_AsVal_int(obj2, &val3);
14819 if (!SWIG_IsOK(ecode3)) {
14820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14821 }
14822 arg3 = static_cast< int >(val3);
14823 {
14824 PyThreadState* __tstate = wxPyBeginAllowThreads();
14825 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14826 wxPyEndAllowThreads(__tstate);
14827 if (PyErr_Occurred()) SWIG_fail;
14828 }
14829 {
14830 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14831 }
14832 return resultobj;
14833 fail:
14834 return NULL;
14835 }
14836
14837
14838 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14839 PyObject *resultobj = 0;
14840 wxGrid *arg1 = (wxGrid *) 0 ;
14841 int arg2 ;
14842 void *argp1 = 0 ;
14843 int res1 = 0 ;
14844 int val2 ;
14845 int ecode2 = 0 ;
14846 PyObject * obj0 = 0 ;
14847 PyObject * obj1 = 0 ;
14848 char * kwnames[] = {
14849 (char *) "self",(char *) "col", NULL
14850 };
14851
14852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14854 if (!SWIG_IsOK(res1)) {
14855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14856 }
14857 arg1 = reinterpret_cast< wxGrid * >(argp1);
14858 ecode2 = SWIG_AsVal_int(obj1, &val2);
14859 if (!SWIG_IsOK(ecode2)) {
14860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14861 }
14862 arg2 = static_cast< int >(val2);
14863 {
14864 PyThreadState* __tstate = wxPyBeginAllowThreads();
14865 (arg1)->SetColFormatBool(arg2);
14866 wxPyEndAllowThreads(__tstate);
14867 if (PyErr_Occurred()) SWIG_fail;
14868 }
14869 resultobj = SWIG_Py_Void();
14870 return resultobj;
14871 fail:
14872 return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj = 0;
14878 wxGrid *arg1 = (wxGrid *) 0 ;
14879 int arg2 ;
14880 void *argp1 = 0 ;
14881 int res1 = 0 ;
14882 int val2 ;
14883 int ecode2 = 0 ;
14884 PyObject * obj0 = 0 ;
14885 PyObject * obj1 = 0 ;
14886 char * kwnames[] = {
14887 (char *) "self",(char *) "col", NULL
14888 };
14889
14890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14892 if (!SWIG_IsOK(res1)) {
14893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14894 }
14895 arg1 = reinterpret_cast< wxGrid * >(argp1);
14896 ecode2 = SWIG_AsVal_int(obj1, &val2);
14897 if (!SWIG_IsOK(ecode2)) {
14898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14899 }
14900 arg2 = static_cast< int >(val2);
14901 {
14902 PyThreadState* __tstate = wxPyBeginAllowThreads();
14903 (arg1)->SetColFormatNumber(arg2);
14904 wxPyEndAllowThreads(__tstate);
14905 if (PyErr_Occurred()) SWIG_fail;
14906 }
14907 resultobj = SWIG_Py_Void();
14908 return resultobj;
14909 fail:
14910 return NULL;
14911 }
14912
14913
14914 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14915 PyObject *resultobj = 0;
14916 wxGrid *arg1 = (wxGrid *) 0 ;
14917 int arg2 ;
14918 int arg3 = (int) -1 ;
14919 int arg4 = (int) -1 ;
14920 void *argp1 = 0 ;
14921 int res1 = 0 ;
14922 int val2 ;
14923 int ecode2 = 0 ;
14924 int val3 ;
14925 int ecode3 = 0 ;
14926 int val4 ;
14927 int ecode4 = 0 ;
14928 PyObject * obj0 = 0 ;
14929 PyObject * obj1 = 0 ;
14930 PyObject * obj2 = 0 ;
14931 PyObject * obj3 = 0 ;
14932 char * kwnames[] = {
14933 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14934 };
14935
14936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_SetColFormatFloat" "', 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_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14945 }
14946 arg2 = static_cast< int >(val2);
14947 if (obj2) {
14948 ecode3 = SWIG_AsVal_int(obj2, &val3);
14949 if (!SWIG_IsOK(ecode3)) {
14950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14951 }
14952 arg3 = static_cast< int >(val3);
14953 }
14954 if (obj3) {
14955 ecode4 = SWIG_AsVal_int(obj3, &val4);
14956 if (!SWIG_IsOK(ecode4)) {
14957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14958 }
14959 arg4 = static_cast< int >(val4);
14960 }
14961 {
14962 PyThreadState* __tstate = wxPyBeginAllowThreads();
14963 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14964 wxPyEndAllowThreads(__tstate);
14965 if (PyErr_Occurred()) SWIG_fail;
14966 }
14967 resultobj = SWIG_Py_Void();
14968 return resultobj;
14969 fail:
14970 return NULL;
14971 }
14972
14973
14974 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14975 PyObject *resultobj = 0;
14976 wxGrid *arg1 = (wxGrid *) 0 ;
14977 int arg2 ;
14978 wxString *arg3 = 0 ;
14979 void *argp1 = 0 ;
14980 int res1 = 0 ;
14981 int val2 ;
14982 int ecode2 = 0 ;
14983 bool temp3 = false ;
14984 PyObject * obj0 = 0 ;
14985 PyObject * obj1 = 0 ;
14986 PyObject * obj2 = 0 ;
14987 char * kwnames[] = {
14988 (char *) "self",(char *) "col",(char *) "typeName", NULL
14989 };
14990
14991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14993 if (!SWIG_IsOK(res1)) {
14994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14995 }
14996 arg1 = reinterpret_cast< wxGrid * >(argp1);
14997 ecode2 = SWIG_AsVal_int(obj1, &val2);
14998 if (!SWIG_IsOK(ecode2)) {
14999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
15000 }
15001 arg2 = static_cast< int >(val2);
15002 {
15003 arg3 = wxString_in_helper(obj2);
15004 if (arg3 == NULL) SWIG_fail;
15005 temp3 = true;
15006 }
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
15010 wxPyEndAllowThreads(__tstate);
15011 if (PyErr_Occurred()) SWIG_fail;
15012 }
15013 resultobj = SWIG_Py_Void();
15014 {
15015 if (temp3)
15016 delete arg3;
15017 }
15018 return resultobj;
15019 fail:
15020 {
15021 if (temp3)
15022 delete arg3;
15023 }
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15029 PyObject *resultobj = 0;
15030 wxGrid *arg1 = (wxGrid *) 0 ;
15031 bool arg2 = (bool) true ;
15032 void *argp1 = 0 ;
15033 int res1 = 0 ;
15034 bool val2 ;
15035 int ecode2 = 0 ;
15036 PyObject * obj0 = 0 ;
15037 PyObject * obj1 = 0 ;
15038 char * kwnames[] = {
15039 (char *) "self",(char *) "enable", NULL
15040 };
15041
15042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
15043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15044 if (!SWIG_IsOK(res1)) {
15045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
15046 }
15047 arg1 = reinterpret_cast< wxGrid * >(argp1);
15048 if (obj1) {
15049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15050 if (!SWIG_IsOK(ecode2)) {
15051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
15052 }
15053 arg2 = static_cast< bool >(val2);
15054 }
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 (arg1)->EnableGridLines(arg2);
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 resultobj = SWIG_Py_Void();
15062 return resultobj;
15063 fail:
15064 return NULL;
15065 }
15066
15067
15068 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15069 PyObject *resultobj = 0;
15070 wxGrid *arg1 = (wxGrid *) 0 ;
15071 bool result;
15072 void *argp1 = 0 ;
15073 int res1 = 0 ;
15074 PyObject *swig_obj[1] ;
15075
15076 if (!args) SWIG_fail;
15077 swig_obj[0] = args;
15078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15079 if (!SWIG_IsOK(res1)) {
15080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
15081 }
15082 arg1 = reinterpret_cast< wxGrid * >(argp1);
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 result = (bool)(arg1)->GridLinesEnabled();
15086 wxPyEndAllowThreads(__tstate);
15087 if (PyErr_Occurred()) SWIG_fail;
15088 }
15089 {
15090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15091 }
15092 return resultobj;
15093 fail:
15094 return NULL;
15095 }
15096
15097
15098 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15099 PyObject *resultobj = 0;
15100 wxGrid *arg1 = (wxGrid *) 0 ;
15101 int result;
15102 void *argp1 = 0 ;
15103 int res1 = 0 ;
15104 PyObject *swig_obj[1] ;
15105
15106 if (!args) SWIG_fail;
15107 swig_obj[0] = args;
15108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15109 if (!SWIG_IsOK(res1)) {
15110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15111 }
15112 arg1 = reinterpret_cast< wxGrid * >(argp1);
15113 {
15114 PyThreadState* __tstate = wxPyBeginAllowThreads();
15115 result = (int)(arg1)->GetDefaultRowSize();
15116 wxPyEndAllowThreads(__tstate);
15117 if (PyErr_Occurred()) SWIG_fail;
15118 }
15119 resultobj = SWIG_From_int(static_cast< int >(result));
15120 return resultobj;
15121 fail:
15122 return NULL;
15123 }
15124
15125
15126 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15127 PyObject *resultobj = 0;
15128 wxGrid *arg1 = (wxGrid *) 0 ;
15129 int arg2 ;
15130 int result;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 int val2 ;
15134 int ecode2 = 0 ;
15135 PyObject * obj0 = 0 ;
15136 PyObject * obj1 = 0 ;
15137 char * kwnames[] = {
15138 (char *) "self",(char *) "row", NULL
15139 };
15140
15141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
15142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15143 if (!SWIG_IsOK(res1)) {
15144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15145 }
15146 arg1 = reinterpret_cast< wxGrid * >(argp1);
15147 ecode2 = SWIG_AsVal_int(obj1, &val2);
15148 if (!SWIG_IsOK(ecode2)) {
15149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
15150 }
15151 arg2 = static_cast< int >(val2);
15152 {
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 result = (int)(arg1)->GetRowSize(arg2);
15155 wxPyEndAllowThreads(__tstate);
15156 if (PyErr_Occurred()) SWIG_fail;
15157 }
15158 resultobj = SWIG_From_int(static_cast< int >(result));
15159 return resultobj;
15160 fail:
15161 return NULL;
15162 }
15163
15164
15165 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15166 PyObject *resultobj = 0;
15167 wxGrid *arg1 = (wxGrid *) 0 ;
15168 int result;
15169 void *argp1 = 0 ;
15170 int res1 = 0 ;
15171 PyObject *swig_obj[1] ;
15172
15173 if (!args) SWIG_fail;
15174 swig_obj[0] = args;
15175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15176 if (!SWIG_IsOK(res1)) {
15177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15178 }
15179 arg1 = reinterpret_cast< wxGrid * >(argp1);
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (int)(arg1)->GetDefaultColSize();
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 resultobj = SWIG_From_int(static_cast< int >(result));
15187 return resultobj;
15188 fail:
15189 return NULL;
15190 }
15191
15192
15193 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15194 PyObject *resultobj = 0;
15195 wxGrid *arg1 = (wxGrid *) 0 ;
15196 int arg2 ;
15197 int result;
15198 void *argp1 = 0 ;
15199 int res1 = 0 ;
15200 int val2 ;
15201 int ecode2 = 0 ;
15202 PyObject * obj0 = 0 ;
15203 PyObject * obj1 = 0 ;
15204 char * kwnames[] = {
15205 (char *) "self",(char *) "col", NULL
15206 };
15207
15208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
15209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15210 if (!SWIG_IsOK(res1)) {
15211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15212 }
15213 arg1 = reinterpret_cast< wxGrid * >(argp1);
15214 ecode2 = SWIG_AsVal_int(obj1, &val2);
15215 if (!SWIG_IsOK(ecode2)) {
15216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
15217 }
15218 arg2 = static_cast< int >(val2);
15219 {
15220 PyThreadState* __tstate = wxPyBeginAllowThreads();
15221 result = (int)(arg1)->GetColSize(arg2);
15222 wxPyEndAllowThreads(__tstate);
15223 if (PyErr_Occurred()) SWIG_fail;
15224 }
15225 resultobj = SWIG_From_int(static_cast< int >(result));
15226 return resultobj;
15227 fail:
15228 return NULL;
15229 }
15230
15231
15232 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15233 PyObject *resultobj = 0;
15234 wxGrid *arg1 = (wxGrid *) 0 ;
15235 wxColour result;
15236 void *argp1 = 0 ;
15237 int res1 = 0 ;
15238 PyObject *swig_obj[1] ;
15239
15240 if (!args) SWIG_fail;
15241 swig_obj[0] = args;
15242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15243 if (!SWIG_IsOK(res1)) {
15244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15245 }
15246 arg1 = reinterpret_cast< wxGrid * >(argp1);
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = (arg1)->GetDefaultCellBackgroundColour();
15250 wxPyEndAllowThreads(__tstate);
15251 if (PyErr_Occurred()) SWIG_fail;
15252 }
15253 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15254 return resultobj;
15255 fail:
15256 return NULL;
15257 }
15258
15259
15260 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15261 PyObject *resultobj = 0;
15262 wxGrid *arg1 = (wxGrid *) 0 ;
15263 int arg2 ;
15264 int arg3 ;
15265 wxColour result;
15266 void *argp1 = 0 ;
15267 int res1 = 0 ;
15268 int val2 ;
15269 int ecode2 = 0 ;
15270 int val3 ;
15271 int ecode3 = 0 ;
15272 PyObject * obj0 = 0 ;
15273 PyObject * obj1 = 0 ;
15274 PyObject * obj2 = 0 ;
15275 char * kwnames[] = {
15276 (char *) "self",(char *) "row",(char *) "col", NULL
15277 };
15278
15279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15281 if (!SWIG_IsOK(res1)) {
15282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15283 }
15284 arg1 = reinterpret_cast< wxGrid * >(argp1);
15285 ecode2 = SWIG_AsVal_int(obj1, &val2);
15286 if (!SWIG_IsOK(ecode2)) {
15287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15288 }
15289 arg2 = static_cast< int >(val2);
15290 ecode3 = SWIG_AsVal_int(obj2, &val3);
15291 if (!SWIG_IsOK(ecode3)) {
15292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15293 }
15294 arg3 = static_cast< int >(val3);
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15302 return resultobj;
15303 fail:
15304 return NULL;
15305 }
15306
15307
15308 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15309 PyObject *resultobj = 0;
15310 wxGrid *arg1 = (wxGrid *) 0 ;
15311 wxColour result;
15312 void *argp1 = 0 ;
15313 int res1 = 0 ;
15314 PyObject *swig_obj[1] ;
15315
15316 if (!args) SWIG_fail;
15317 swig_obj[0] = args;
15318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15319 if (!SWIG_IsOK(res1)) {
15320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15321 }
15322 arg1 = reinterpret_cast< wxGrid * >(argp1);
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 result = (arg1)->GetDefaultCellTextColour();
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15337 PyObject *resultobj = 0;
15338 wxGrid *arg1 = (wxGrid *) 0 ;
15339 int arg2 ;
15340 int arg3 ;
15341 wxColour result;
15342 void *argp1 = 0 ;
15343 int res1 = 0 ;
15344 int val2 ;
15345 int ecode2 = 0 ;
15346 int val3 ;
15347 int ecode3 = 0 ;
15348 PyObject * obj0 = 0 ;
15349 PyObject * obj1 = 0 ;
15350 PyObject * obj2 = 0 ;
15351 char * kwnames[] = {
15352 (char *) "self",(char *) "row",(char *) "col", NULL
15353 };
15354
15355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15357 if (!SWIG_IsOK(res1)) {
15358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15359 }
15360 arg1 = reinterpret_cast< wxGrid * >(argp1);
15361 ecode2 = SWIG_AsVal_int(obj1, &val2);
15362 if (!SWIG_IsOK(ecode2)) {
15363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15364 }
15365 arg2 = static_cast< int >(val2);
15366 ecode3 = SWIG_AsVal_int(obj2, &val3);
15367 if (!SWIG_IsOK(ecode3)) {
15368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15369 }
15370 arg3 = static_cast< int >(val3);
15371 {
15372 PyThreadState* __tstate = wxPyBeginAllowThreads();
15373 result = (arg1)->GetCellTextColour(arg2,arg3);
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15385 PyObject *resultobj = 0;
15386 wxGrid *arg1 = (wxGrid *) 0 ;
15387 wxFont result;
15388 void *argp1 = 0 ;
15389 int res1 = 0 ;
15390 PyObject *swig_obj[1] ;
15391
15392 if (!args) SWIG_fail;
15393 swig_obj[0] = args;
15394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15395 if (!SWIG_IsOK(res1)) {
15396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15397 }
15398 arg1 = reinterpret_cast< wxGrid * >(argp1);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (arg1)->GetDefaultCellFont();
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15413 PyObject *resultobj = 0;
15414 wxGrid *arg1 = (wxGrid *) 0 ;
15415 int arg2 ;
15416 int arg3 ;
15417 wxFont result;
15418 void *argp1 = 0 ;
15419 int res1 = 0 ;
15420 int val2 ;
15421 int ecode2 = 0 ;
15422 int val3 ;
15423 int ecode3 = 0 ;
15424 PyObject * obj0 = 0 ;
15425 PyObject * obj1 = 0 ;
15426 PyObject * obj2 = 0 ;
15427 char * kwnames[] = {
15428 (char *) "self",(char *) "row",(char *) "col", NULL
15429 };
15430
15431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15433 if (!SWIG_IsOK(res1)) {
15434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15435 }
15436 arg1 = reinterpret_cast< wxGrid * >(argp1);
15437 ecode2 = SWIG_AsVal_int(obj1, &val2);
15438 if (!SWIG_IsOK(ecode2)) {
15439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15440 }
15441 arg2 = static_cast< int >(val2);
15442 ecode3 = SWIG_AsVal_int(obj2, &val3);
15443 if (!SWIG_IsOK(ecode3)) {
15444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15445 }
15446 arg3 = static_cast< int >(val3);
15447 {
15448 PyThreadState* __tstate = wxPyBeginAllowThreads();
15449 result = (arg1)->GetCellFont(arg2,arg3);
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15461 PyObject *resultobj = 0;
15462 wxGrid *arg1 = (wxGrid *) 0 ;
15463 int *arg2 = (int *) 0 ;
15464 int *arg3 = (int *) 0 ;
15465 void *argp1 = 0 ;
15466 int res1 = 0 ;
15467 int temp2 ;
15468 int res2 = SWIG_TMPOBJ ;
15469 int temp3 ;
15470 int res3 = SWIG_TMPOBJ ;
15471 PyObject *swig_obj[1] ;
15472
15473 arg2 = &temp2;
15474 arg3 = &temp3;
15475 if (!args) SWIG_fail;
15476 swig_obj[0] = args;
15477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15478 if (!SWIG_IsOK(res1)) {
15479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15480 }
15481 arg1 = reinterpret_cast< wxGrid * >(argp1);
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 resultobj = SWIG_Py_Void();
15489 if (SWIG_IsTmpObj(res2)) {
15490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15491 } else {
15492 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15494 }
15495 if (SWIG_IsTmpObj(res3)) {
15496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15497 } else {
15498 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15500 }
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15508 PyObject *resultobj = 0;
15509 wxGrid *arg1 = (wxGrid *) 0 ;
15510 int arg2 ;
15511 int arg3 ;
15512 int *arg4 = (int *) 0 ;
15513 int *arg5 = (int *) 0 ;
15514 void *argp1 = 0 ;
15515 int res1 = 0 ;
15516 int val2 ;
15517 int ecode2 = 0 ;
15518 int val3 ;
15519 int ecode3 = 0 ;
15520 int temp4 ;
15521 int res4 = SWIG_TMPOBJ ;
15522 int temp5 ;
15523 int res5 = SWIG_TMPOBJ ;
15524 PyObject * obj0 = 0 ;
15525 PyObject * obj1 = 0 ;
15526 PyObject * obj2 = 0 ;
15527 char * kwnames[] = {
15528 (char *) "self",(char *) "row",(char *) "col", NULL
15529 };
15530
15531 arg4 = &temp4;
15532 arg5 = &temp5;
15533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15535 if (!SWIG_IsOK(res1)) {
15536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15537 }
15538 arg1 = reinterpret_cast< wxGrid * >(argp1);
15539 ecode2 = SWIG_AsVal_int(obj1, &val2);
15540 if (!SWIG_IsOK(ecode2)) {
15541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15542 }
15543 arg2 = static_cast< int >(val2);
15544 ecode3 = SWIG_AsVal_int(obj2, &val3);
15545 if (!SWIG_IsOK(ecode3)) {
15546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15547 }
15548 arg3 = static_cast< int >(val3);
15549 {
15550 PyThreadState* __tstate = wxPyBeginAllowThreads();
15551 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15552 wxPyEndAllowThreads(__tstate);
15553 if (PyErr_Occurred()) SWIG_fail;
15554 }
15555 resultobj = SWIG_Py_Void();
15556 if (SWIG_IsTmpObj(res4)) {
15557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15558 } else {
15559 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15561 }
15562 if (SWIG_IsTmpObj(res5)) {
15563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15564 } else {
15565 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15567 }
15568 return resultobj;
15569 fail:
15570 return NULL;
15571 }
15572
15573
15574 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15575 PyObject *resultobj = 0;
15576 wxGrid *arg1 = (wxGrid *) 0 ;
15577 bool result;
15578 void *argp1 = 0 ;
15579 int res1 = 0 ;
15580 PyObject *swig_obj[1] ;
15581
15582 if (!args) SWIG_fail;
15583 swig_obj[0] = args;
15584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15585 if (!SWIG_IsOK(res1)) {
15586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15587 }
15588 arg1 = reinterpret_cast< wxGrid * >(argp1);
15589 {
15590 PyThreadState* __tstate = wxPyBeginAllowThreads();
15591 result = (bool)(arg1)->GetDefaultCellOverflow();
15592 wxPyEndAllowThreads(__tstate);
15593 if (PyErr_Occurred()) SWIG_fail;
15594 }
15595 {
15596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15597 }
15598 return resultobj;
15599 fail:
15600 return NULL;
15601 }
15602
15603
15604 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15605 PyObject *resultobj = 0;
15606 wxGrid *arg1 = (wxGrid *) 0 ;
15607 int arg2 ;
15608 int arg3 ;
15609 bool result;
15610 void *argp1 = 0 ;
15611 int res1 = 0 ;
15612 int val2 ;
15613 int ecode2 = 0 ;
15614 int val3 ;
15615 int ecode3 = 0 ;
15616 PyObject * obj0 = 0 ;
15617 PyObject * obj1 = 0 ;
15618 PyObject * obj2 = 0 ;
15619 char * kwnames[] = {
15620 (char *) "self",(char *) "row",(char *) "col", NULL
15621 };
15622
15623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15625 if (!SWIG_IsOK(res1)) {
15626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15627 }
15628 arg1 = reinterpret_cast< wxGrid * >(argp1);
15629 ecode2 = SWIG_AsVal_int(obj1, &val2);
15630 if (!SWIG_IsOK(ecode2)) {
15631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15632 }
15633 arg2 = static_cast< int >(val2);
15634 ecode3 = SWIG_AsVal_int(obj2, &val3);
15635 if (!SWIG_IsOK(ecode3)) {
15636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15637 }
15638 arg3 = static_cast< int >(val3);
15639 {
15640 PyThreadState* __tstate = wxPyBeginAllowThreads();
15641 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15642 wxPyEndAllowThreads(__tstate);
15643 if (PyErr_Occurred()) SWIG_fail;
15644 }
15645 {
15646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15647 }
15648 return resultobj;
15649 fail:
15650 return NULL;
15651 }
15652
15653
15654 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15655 PyObject *resultobj = 0;
15656 wxGrid *arg1 = (wxGrid *) 0 ;
15657 int arg2 ;
15658 int arg3 ;
15659 int *arg4 = (int *) 0 ;
15660 int *arg5 = (int *) 0 ;
15661 void *argp1 = 0 ;
15662 int res1 = 0 ;
15663 int val2 ;
15664 int ecode2 = 0 ;
15665 int val3 ;
15666 int ecode3 = 0 ;
15667 int temp4 ;
15668 int res4 = SWIG_TMPOBJ ;
15669 int temp5 ;
15670 int res5 = SWIG_TMPOBJ ;
15671 PyObject * obj0 = 0 ;
15672 PyObject * obj1 = 0 ;
15673 PyObject * obj2 = 0 ;
15674 char * kwnames[] = {
15675 (char *) "self",(char *) "row",(char *) "col", NULL
15676 };
15677
15678 arg4 = &temp4;
15679 arg5 = &temp5;
15680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15682 if (!SWIG_IsOK(res1)) {
15683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15684 }
15685 arg1 = reinterpret_cast< wxGrid * >(argp1);
15686 ecode2 = SWIG_AsVal_int(obj1, &val2);
15687 if (!SWIG_IsOK(ecode2)) {
15688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15689 }
15690 arg2 = static_cast< int >(val2);
15691 ecode3 = SWIG_AsVal_int(obj2, &val3);
15692 if (!SWIG_IsOK(ecode3)) {
15693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15694 }
15695 arg3 = static_cast< int >(val3);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 resultobj = SWIG_Py_Void();
15703 if (SWIG_IsTmpObj(res4)) {
15704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15705 } else {
15706 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15708 }
15709 if (SWIG_IsTmpObj(res5)) {
15710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15711 } else {
15712 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15714 }
15715 return resultobj;
15716 fail:
15717 return NULL;
15718 }
15719
15720
15721 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15722 PyObject *resultobj = 0;
15723 wxGrid *arg1 = (wxGrid *) 0 ;
15724 int arg2 ;
15725 bool arg3 = (bool) false ;
15726 void *argp1 = 0 ;
15727 int res1 = 0 ;
15728 int val2 ;
15729 int ecode2 = 0 ;
15730 bool val3 ;
15731 int ecode3 = 0 ;
15732 PyObject * obj0 = 0 ;
15733 PyObject * obj1 = 0 ;
15734 PyObject * obj2 = 0 ;
15735 char * kwnames[] = {
15736 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15737 };
15738
15739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15741 if (!SWIG_IsOK(res1)) {
15742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15743 }
15744 arg1 = reinterpret_cast< wxGrid * >(argp1);
15745 ecode2 = SWIG_AsVal_int(obj1, &val2);
15746 if (!SWIG_IsOK(ecode2)) {
15747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15748 }
15749 arg2 = static_cast< int >(val2);
15750 if (obj2) {
15751 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15752 if (!SWIG_IsOK(ecode3)) {
15753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15754 }
15755 arg3 = static_cast< bool >(val3);
15756 }
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 (arg1)->SetDefaultRowSize(arg2,arg3);
15760 wxPyEndAllowThreads(__tstate);
15761 if (PyErr_Occurred()) SWIG_fail;
15762 }
15763 resultobj = SWIG_Py_Void();
15764 return resultobj;
15765 fail:
15766 return NULL;
15767 }
15768
15769
15770 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15771 PyObject *resultobj = 0;
15772 wxGrid *arg1 = (wxGrid *) 0 ;
15773 int arg2 ;
15774 int arg3 ;
15775 void *argp1 = 0 ;
15776 int res1 = 0 ;
15777 int val2 ;
15778 int ecode2 = 0 ;
15779 int val3 ;
15780 int ecode3 = 0 ;
15781 PyObject * obj0 = 0 ;
15782 PyObject * obj1 = 0 ;
15783 PyObject * obj2 = 0 ;
15784 char * kwnames[] = {
15785 (char *) "self",(char *) "row",(char *) "height", NULL
15786 };
15787
15788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15790 if (!SWIG_IsOK(res1)) {
15791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15792 }
15793 arg1 = reinterpret_cast< wxGrid * >(argp1);
15794 ecode2 = SWIG_AsVal_int(obj1, &val2);
15795 if (!SWIG_IsOK(ecode2)) {
15796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15797 }
15798 arg2 = static_cast< int >(val2);
15799 ecode3 = SWIG_AsVal_int(obj2, &val3);
15800 if (!SWIG_IsOK(ecode3)) {
15801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15802 }
15803 arg3 = static_cast< int >(val3);
15804 {
15805 PyThreadState* __tstate = wxPyBeginAllowThreads();
15806 (arg1)->SetRowSize(arg2,arg3);
15807 wxPyEndAllowThreads(__tstate);
15808 if (PyErr_Occurred()) SWIG_fail;
15809 }
15810 resultobj = SWIG_Py_Void();
15811 return resultobj;
15812 fail:
15813 return NULL;
15814 }
15815
15816
15817 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15818 PyObject *resultobj = 0;
15819 wxGrid *arg1 = (wxGrid *) 0 ;
15820 int arg2 ;
15821 bool arg3 = (bool) false ;
15822 void *argp1 = 0 ;
15823 int res1 = 0 ;
15824 int val2 ;
15825 int ecode2 = 0 ;
15826 bool val3 ;
15827 int ecode3 = 0 ;
15828 PyObject * obj0 = 0 ;
15829 PyObject * obj1 = 0 ;
15830 PyObject * obj2 = 0 ;
15831 char * kwnames[] = {
15832 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15833 };
15834
15835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15837 if (!SWIG_IsOK(res1)) {
15838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15839 }
15840 arg1 = reinterpret_cast< wxGrid * >(argp1);
15841 ecode2 = SWIG_AsVal_int(obj1, &val2);
15842 if (!SWIG_IsOK(ecode2)) {
15843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15844 }
15845 arg2 = static_cast< int >(val2);
15846 if (obj2) {
15847 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15848 if (!SWIG_IsOK(ecode3)) {
15849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15850 }
15851 arg3 = static_cast< bool >(val3);
15852 }
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 (arg1)->SetDefaultColSize(arg2,arg3);
15856 wxPyEndAllowThreads(__tstate);
15857 if (PyErr_Occurred()) SWIG_fail;
15858 }
15859 resultobj = SWIG_Py_Void();
15860 return resultobj;
15861 fail:
15862 return NULL;
15863 }
15864
15865
15866 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15867 PyObject *resultobj = 0;
15868 wxGrid *arg1 = (wxGrid *) 0 ;
15869 int arg2 ;
15870 int arg3 ;
15871 void *argp1 = 0 ;
15872 int res1 = 0 ;
15873 int val2 ;
15874 int ecode2 = 0 ;
15875 int val3 ;
15876 int ecode3 = 0 ;
15877 PyObject * obj0 = 0 ;
15878 PyObject * obj1 = 0 ;
15879 PyObject * obj2 = 0 ;
15880 char * kwnames[] = {
15881 (char *) "self",(char *) "col",(char *) "width", NULL
15882 };
15883
15884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15886 if (!SWIG_IsOK(res1)) {
15887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15888 }
15889 arg1 = reinterpret_cast< wxGrid * >(argp1);
15890 ecode2 = SWIG_AsVal_int(obj1, &val2);
15891 if (!SWIG_IsOK(ecode2)) {
15892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15893 }
15894 arg2 = static_cast< int >(val2);
15895 ecode3 = SWIG_AsVal_int(obj2, &val3);
15896 if (!SWIG_IsOK(ecode3)) {
15897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15898 }
15899 arg3 = static_cast< int >(val3);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 (arg1)->SetColSize(arg2,arg3);
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_Py_Void();
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj = 0;
15915 wxGrid *arg1 = (wxGrid *) 0 ;
15916 int arg2 ;
15917 int result;
15918 void *argp1 = 0 ;
15919 int res1 = 0 ;
15920 int val2 ;
15921 int ecode2 = 0 ;
15922 PyObject * obj0 = 0 ;
15923 PyObject * obj1 = 0 ;
15924 char * kwnames[] = {
15925 (char *) "self",(char *) "colPos", NULL
15926 };
15927
15928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15930 if (!SWIG_IsOK(res1)) {
15931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15932 }
15933 arg1 = reinterpret_cast< wxGrid * >(argp1);
15934 ecode2 = SWIG_AsVal_int(obj1, &val2);
15935 if (!SWIG_IsOK(ecode2)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15937 }
15938 arg2 = static_cast< int >(val2);
15939 {
15940 PyThreadState* __tstate = wxPyBeginAllowThreads();
15941 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15942 wxPyEndAllowThreads(__tstate);
15943 if (PyErr_Occurred()) SWIG_fail;
15944 }
15945 resultobj = SWIG_From_int(static_cast< int >(result));
15946 return resultobj;
15947 fail:
15948 return NULL;
15949 }
15950
15951
15952 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15953 PyObject *resultobj = 0;
15954 wxGrid *arg1 = (wxGrid *) 0 ;
15955 int arg2 ;
15956 int arg3 ;
15957 void *argp1 = 0 ;
15958 int res1 = 0 ;
15959 int val2 ;
15960 int ecode2 = 0 ;
15961 int val3 ;
15962 int ecode3 = 0 ;
15963 PyObject * obj0 = 0 ;
15964 PyObject * obj1 = 0 ;
15965 PyObject * obj2 = 0 ;
15966 char * kwnames[] = {
15967 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15968 };
15969
15970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15974 }
15975 arg1 = reinterpret_cast< wxGrid * >(argp1);
15976 ecode2 = SWIG_AsVal_int(obj1, &val2);
15977 if (!SWIG_IsOK(ecode2)) {
15978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15979 }
15980 arg2 = static_cast< int >(val2);
15981 ecode3 = SWIG_AsVal_int(obj2, &val3);
15982 if (!SWIG_IsOK(ecode3)) {
15983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15984 }
15985 arg3 = static_cast< int >(val3);
15986 {
15987 PyThreadState* __tstate = wxPyBeginAllowThreads();
15988 (arg1)->SetColPos(arg2,arg3);
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 resultobj = SWIG_Py_Void();
15993 return resultobj;
15994 fail:
15995 return NULL;
15996 }
15997
15998
15999 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16000 PyObject *resultobj = 0;
16001 wxGrid *arg1 = (wxGrid *) 0 ;
16002 int arg2 ;
16003 int result;
16004 void *argp1 = 0 ;
16005 int res1 = 0 ;
16006 int val2 ;
16007 int ecode2 = 0 ;
16008 PyObject * obj0 = 0 ;
16009 PyObject * obj1 = 0 ;
16010 char * kwnames[] = {
16011 (char *) "self",(char *) "colID", NULL
16012 };
16013
16014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
16015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16016 if (!SWIG_IsOK(res1)) {
16017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
16018 }
16019 arg1 = reinterpret_cast< wxGrid * >(argp1);
16020 ecode2 = SWIG_AsVal_int(obj1, &val2);
16021 if (!SWIG_IsOK(ecode2)) {
16022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
16023 }
16024 arg2 = static_cast< int >(val2);
16025 {
16026 PyThreadState* __tstate = wxPyBeginAllowThreads();
16027 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 resultobj = SWIG_From_int(static_cast< int >(result));
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj = 0;
16040 wxGrid *arg1 = (wxGrid *) 0 ;
16041 int arg2 ;
16042 bool arg3 = (bool) true ;
16043 void *argp1 = 0 ;
16044 int res1 = 0 ;
16045 int val2 ;
16046 int ecode2 = 0 ;
16047 bool val3 ;
16048 int ecode3 = 0 ;
16049 PyObject * obj0 = 0 ;
16050 PyObject * obj1 = 0 ;
16051 PyObject * obj2 = 0 ;
16052 char * kwnames[] = {
16053 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
16054 };
16055
16056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16058 if (!SWIG_IsOK(res1)) {
16059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
16060 }
16061 arg1 = reinterpret_cast< wxGrid * >(argp1);
16062 ecode2 = SWIG_AsVal_int(obj1, &val2);
16063 if (!SWIG_IsOK(ecode2)) {
16064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
16065 }
16066 arg2 = static_cast< int >(val2);
16067 if (obj2) {
16068 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16069 if (!SWIG_IsOK(ecode3)) {
16070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
16071 }
16072 arg3 = static_cast< bool >(val3);
16073 }
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 (arg1)->AutoSizeColumn(arg2,arg3);
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 resultobj = SWIG_Py_Void();
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16088 PyObject *resultobj = 0;
16089 wxGrid *arg1 = (wxGrid *) 0 ;
16090 int arg2 ;
16091 bool arg3 = (bool) true ;
16092 void *argp1 = 0 ;
16093 int res1 = 0 ;
16094 int val2 ;
16095 int ecode2 = 0 ;
16096 bool val3 ;
16097 int ecode3 = 0 ;
16098 PyObject * obj0 = 0 ;
16099 PyObject * obj1 = 0 ;
16100 PyObject * obj2 = 0 ;
16101 char * kwnames[] = {
16102 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
16103 };
16104
16105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16107 if (!SWIG_IsOK(res1)) {
16108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
16109 }
16110 arg1 = reinterpret_cast< wxGrid * >(argp1);
16111 ecode2 = SWIG_AsVal_int(obj1, &val2);
16112 if (!SWIG_IsOK(ecode2)) {
16113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
16114 }
16115 arg2 = static_cast< int >(val2);
16116 if (obj2) {
16117 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16118 if (!SWIG_IsOK(ecode3)) {
16119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
16120 }
16121 arg3 = static_cast< bool >(val3);
16122 }
16123 {
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 (arg1)->AutoSizeRow(arg2,arg3);
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 resultobj = SWIG_Py_Void();
16130 return resultobj;
16131 fail:
16132 return NULL;
16133 }
16134
16135
16136 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16137 PyObject *resultobj = 0;
16138 wxGrid *arg1 = (wxGrid *) 0 ;
16139 bool arg2 = (bool) true ;
16140 void *argp1 = 0 ;
16141 int res1 = 0 ;
16142 bool val2 ;
16143 int ecode2 = 0 ;
16144 PyObject * obj0 = 0 ;
16145 PyObject * obj1 = 0 ;
16146 char * kwnames[] = {
16147 (char *) "self",(char *) "setAsMin", NULL
16148 };
16149
16150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
16151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16152 if (!SWIG_IsOK(res1)) {
16153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
16154 }
16155 arg1 = reinterpret_cast< wxGrid * >(argp1);
16156 if (obj1) {
16157 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16158 if (!SWIG_IsOK(ecode2)) {
16159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
16160 }
16161 arg2 = static_cast< bool >(val2);
16162 }
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 (arg1)->AutoSizeColumns(arg2);
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 resultobj = SWIG_Py_Void();
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16177 PyObject *resultobj = 0;
16178 wxGrid *arg1 = (wxGrid *) 0 ;
16179 bool arg2 = (bool) true ;
16180 void *argp1 = 0 ;
16181 int res1 = 0 ;
16182 bool val2 ;
16183 int ecode2 = 0 ;
16184 PyObject * obj0 = 0 ;
16185 PyObject * obj1 = 0 ;
16186 char * kwnames[] = {
16187 (char *) "self",(char *) "setAsMin", NULL
16188 };
16189
16190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
16191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16192 if (!SWIG_IsOK(res1)) {
16193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
16194 }
16195 arg1 = reinterpret_cast< wxGrid * >(argp1);
16196 if (obj1) {
16197 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16198 if (!SWIG_IsOK(ecode2)) {
16199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
16200 }
16201 arg2 = static_cast< bool >(val2);
16202 }
16203 {
16204 PyThreadState* __tstate = wxPyBeginAllowThreads();
16205 (arg1)->AutoSizeRows(arg2);
16206 wxPyEndAllowThreads(__tstate);
16207 if (PyErr_Occurred()) SWIG_fail;
16208 }
16209 resultobj = SWIG_Py_Void();
16210 return resultobj;
16211 fail:
16212 return NULL;
16213 }
16214
16215
16216 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16217 PyObject *resultobj = 0;
16218 wxGrid *arg1 = (wxGrid *) 0 ;
16219 void *argp1 = 0 ;
16220 int res1 = 0 ;
16221 PyObject *swig_obj[1] ;
16222
16223 if (!args) SWIG_fail;
16224 swig_obj[0] = args;
16225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16226 if (!SWIG_IsOK(res1)) {
16227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16228 }
16229 arg1 = reinterpret_cast< wxGrid * >(argp1);
16230 {
16231 PyThreadState* __tstate = wxPyBeginAllowThreads();
16232 (arg1)->AutoSize();
16233 wxPyEndAllowThreads(__tstate);
16234 if (PyErr_Occurred()) SWIG_fail;
16235 }
16236 resultobj = SWIG_Py_Void();
16237 return resultobj;
16238 fail:
16239 return NULL;
16240 }
16241
16242
16243 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj = 0;
16245 wxGrid *arg1 = (wxGrid *) 0 ;
16246 int arg2 ;
16247 void *argp1 = 0 ;
16248 int res1 = 0 ;
16249 int val2 ;
16250 int ecode2 = 0 ;
16251 PyObject * obj0 = 0 ;
16252 PyObject * obj1 = 0 ;
16253 char * kwnames[] = {
16254 (char *) "self",(char *) "row", NULL
16255 };
16256
16257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16259 if (!SWIG_IsOK(res1)) {
16260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16261 }
16262 arg1 = reinterpret_cast< wxGrid * >(argp1);
16263 ecode2 = SWIG_AsVal_int(obj1, &val2);
16264 if (!SWIG_IsOK(ecode2)) {
16265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
16266 }
16267 arg2 = static_cast< int >(val2);
16268 {
16269 PyThreadState* __tstate = wxPyBeginAllowThreads();
16270 (arg1)->AutoSizeRowLabelSize(arg2);
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 resultobj = SWIG_Py_Void();
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16282 PyObject *resultobj = 0;
16283 wxGrid *arg1 = (wxGrid *) 0 ;
16284 int arg2 ;
16285 void *argp1 = 0 ;
16286 int res1 = 0 ;
16287 int val2 ;
16288 int ecode2 = 0 ;
16289 PyObject * obj0 = 0 ;
16290 PyObject * obj1 = 0 ;
16291 char * kwnames[] = {
16292 (char *) "self",(char *) "col", NULL
16293 };
16294
16295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16297 if (!SWIG_IsOK(res1)) {
16298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16299 }
16300 arg1 = reinterpret_cast< wxGrid * >(argp1);
16301 ecode2 = SWIG_AsVal_int(obj1, &val2);
16302 if (!SWIG_IsOK(ecode2)) {
16303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16304 }
16305 arg2 = static_cast< int >(val2);
16306 {
16307 PyThreadState* __tstate = wxPyBeginAllowThreads();
16308 (arg1)->AutoSizeColLabelSize(arg2);
16309 wxPyEndAllowThreads(__tstate);
16310 if (PyErr_Occurred()) SWIG_fail;
16311 }
16312 resultobj = SWIG_Py_Void();
16313 return resultobj;
16314 fail:
16315 return NULL;
16316 }
16317
16318
16319 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16320 PyObject *resultobj = 0;
16321 wxGrid *arg1 = (wxGrid *) 0 ;
16322 int arg2 ;
16323 int arg3 ;
16324 void *argp1 = 0 ;
16325 int res1 = 0 ;
16326 int val2 ;
16327 int ecode2 = 0 ;
16328 int val3 ;
16329 int ecode3 = 0 ;
16330 PyObject * obj0 = 0 ;
16331 PyObject * obj1 = 0 ;
16332 PyObject * obj2 = 0 ;
16333 char * kwnames[] = {
16334 (char *) "self",(char *) "col",(char *) "width", NULL
16335 };
16336
16337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16339 if (!SWIG_IsOK(res1)) {
16340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16341 }
16342 arg1 = reinterpret_cast< wxGrid * >(argp1);
16343 ecode2 = SWIG_AsVal_int(obj1, &val2);
16344 if (!SWIG_IsOK(ecode2)) {
16345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16346 }
16347 arg2 = static_cast< int >(val2);
16348 ecode3 = SWIG_AsVal_int(obj2, &val3);
16349 if (!SWIG_IsOK(ecode3)) {
16350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16351 }
16352 arg3 = static_cast< int >(val3);
16353 {
16354 PyThreadState* __tstate = wxPyBeginAllowThreads();
16355 (arg1)->SetColMinimalWidth(arg2,arg3);
16356 wxPyEndAllowThreads(__tstate);
16357 if (PyErr_Occurred()) SWIG_fail;
16358 }
16359 resultobj = SWIG_Py_Void();
16360 return resultobj;
16361 fail:
16362 return NULL;
16363 }
16364
16365
16366 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16367 PyObject *resultobj = 0;
16368 wxGrid *arg1 = (wxGrid *) 0 ;
16369 int arg2 ;
16370 int arg3 ;
16371 void *argp1 = 0 ;
16372 int res1 = 0 ;
16373 int val2 ;
16374 int ecode2 = 0 ;
16375 int val3 ;
16376 int ecode3 = 0 ;
16377 PyObject * obj0 = 0 ;
16378 PyObject * obj1 = 0 ;
16379 PyObject * obj2 = 0 ;
16380 char * kwnames[] = {
16381 (char *) "self",(char *) "row",(char *) "width", NULL
16382 };
16383
16384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16386 if (!SWIG_IsOK(res1)) {
16387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16388 }
16389 arg1 = reinterpret_cast< wxGrid * >(argp1);
16390 ecode2 = SWIG_AsVal_int(obj1, &val2);
16391 if (!SWIG_IsOK(ecode2)) {
16392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16393 }
16394 arg2 = static_cast< int >(val2);
16395 ecode3 = SWIG_AsVal_int(obj2, &val3);
16396 if (!SWIG_IsOK(ecode3)) {
16397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16398 }
16399 arg3 = static_cast< int >(val3);
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 (arg1)->SetRowMinimalHeight(arg2,arg3);
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 resultobj = SWIG_Py_Void();
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16414 PyObject *resultobj = 0;
16415 wxGrid *arg1 = (wxGrid *) 0 ;
16416 int arg2 ;
16417 void *argp1 = 0 ;
16418 int res1 = 0 ;
16419 int val2 ;
16420 int ecode2 = 0 ;
16421 PyObject * obj0 = 0 ;
16422 PyObject * obj1 = 0 ;
16423 char * kwnames[] = {
16424 (char *) "self",(char *) "width", NULL
16425 };
16426
16427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16429 if (!SWIG_IsOK(res1)) {
16430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16431 }
16432 arg1 = reinterpret_cast< wxGrid * >(argp1);
16433 ecode2 = SWIG_AsVal_int(obj1, &val2);
16434 if (!SWIG_IsOK(ecode2)) {
16435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16436 }
16437 arg2 = static_cast< int >(val2);
16438 {
16439 PyThreadState* __tstate = wxPyBeginAllowThreads();
16440 (arg1)->SetColMinimalAcceptableWidth(arg2);
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 resultobj = SWIG_Py_Void();
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj = 0;
16453 wxGrid *arg1 = (wxGrid *) 0 ;
16454 int arg2 ;
16455 void *argp1 = 0 ;
16456 int res1 = 0 ;
16457 int val2 ;
16458 int ecode2 = 0 ;
16459 PyObject * obj0 = 0 ;
16460 PyObject * obj1 = 0 ;
16461 char * kwnames[] = {
16462 (char *) "self",(char *) "width", NULL
16463 };
16464
16465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16467 if (!SWIG_IsOK(res1)) {
16468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16469 }
16470 arg1 = reinterpret_cast< wxGrid * >(argp1);
16471 ecode2 = SWIG_AsVal_int(obj1, &val2);
16472 if (!SWIG_IsOK(ecode2)) {
16473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16474 }
16475 arg2 = static_cast< int >(val2);
16476 {
16477 PyThreadState* __tstate = wxPyBeginAllowThreads();
16478 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 resultobj = SWIG_Py_Void();
16483 return resultobj;
16484 fail:
16485 return NULL;
16486 }
16487
16488
16489 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16490 PyObject *resultobj = 0;
16491 wxGrid *arg1 = (wxGrid *) 0 ;
16492 int result;
16493 void *argp1 = 0 ;
16494 int res1 = 0 ;
16495 PyObject *swig_obj[1] ;
16496
16497 if (!args) SWIG_fail;
16498 swig_obj[0] = args;
16499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16500 if (!SWIG_IsOK(res1)) {
16501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16502 }
16503 arg1 = reinterpret_cast< wxGrid * >(argp1);
16504 {
16505 PyThreadState* __tstate = wxPyBeginAllowThreads();
16506 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16507 wxPyEndAllowThreads(__tstate);
16508 if (PyErr_Occurred()) SWIG_fail;
16509 }
16510 resultobj = SWIG_From_int(static_cast< int >(result));
16511 return resultobj;
16512 fail:
16513 return NULL;
16514 }
16515
16516
16517 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16518 PyObject *resultobj = 0;
16519 wxGrid *arg1 = (wxGrid *) 0 ;
16520 int result;
16521 void *argp1 = 0 ;
16522 int res1 = 0 ;
16523 PyObject *swig_obj[1] ;
16524
16525 if (!args) SWIG_fail;
16526 swig_obj[0] = args;
16527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16528 if (!SWIG_IsOK(res1)) {
16529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16530 }
16531 arg1 = reinterpret_cast< wxGrid * >(argp1);
16532 {
16533 PyThreadState* __tstate = wxPyBeginAllowThreads();
16534 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 resultobj = SWIG_From_int(static_cast< int >(result));
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj = 0;
16547 wxGrid *arg1 = (wxGrid *) 0 ;
16548 wxColour *arg2 = 0 ;
16549 void *argp1 = 0 ;
16550 int res1 = 0 ;
16551 wxColour temp2 ;
16552 PyObject * obj0 = 0 ;
16553 PyObject * obj1 = 0 ;
16554 char * kwnames[] = {
16555 (char *) "self",(char *)"arg2", NULL
16556 };
16557
16558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16560 if (!SWIG_IsOK(res1)) {
16561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16562 }
16563 arg1 = reinterpret_cast< wxGrid * >(argp1);
16564 {
16565 arg2 = &temp2;
16566 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16567 }
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 resultobj = SWIG_Py_Void();
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16582 PyObject *resultobj = 0;
16583 wxGrid *arg1 = (wxGrid *) 0 ;
16584 int arg2 ;
16585 int arg3 ;
16586 wxColour *arg4 = 0 ;
16587 void *argp1 = 0 ;
16588 int res1 = 0 ;
16589 int val2 ;
16590 int ecode2 = 0 ;
16591 int val3 ;
16592 int ecode3 = 0 ;
16593 wxColour temp4 ;
16594 PyObject * obj0 = 0 ;
16595 PyObject * obj1 = 0 ;
16596 PyObject * obj2 = 0 ;
16597 PyObject * obj3 = 0 ;
16598 char * kwnames[] = {
16599 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16600 };
16601
16602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16604 if (!SWIG_IsOK(res1)) {
16605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16606 }
16607 arg1 = reinterpret_cast< wxGrid * >(argp1);
16608 ecode2 = SWIG_AsVal_int(obj1, &val2);
16609 if (!SWIG_IsOK(ecode2)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16611 }
16612 arg2 = static_cast< int >(val2);
16613 ecode3 = SWIG_AsVal_int(obj2, &val3);
16614 if (!SWIG_IsOK(ecode3)) {
16615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16616 }
16617 arg3 = static_cast< int >(val3);
16618 {
16619 arg4 = &temp4;
16620 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16621 }
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 resultobj = SWIG_Py_Void();
16629 return resultobj;
16630 fail:
16631 return NULL;
16632 }
16633
16634
16635 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16636 PyObject *resultobj = 0;
16637 wxGrid *arg1 = (wxGrid *) 0 ;
16638 wxColour *arg2 = 0 ;
16639 void *argp1 = 0 ;
16640 int res1 = 0 ;
16641 wxColour temp2 ;
16642 PyObject * obj0 = 0 ;
16643 PyObject * obj1 = 0 ;
16644 char * kwnames[] = {
16645 (char *) "self",(char *)"arg2", NULL
16646 };
16647
16648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16650 if (!SWIG_IsOK(res1)) {
16651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16652 }
16653 arg1 = reinterpret_cast< wxGrid * >(argp1);
16654 {
16655 arg2 = &temp2;
16656 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16657 }
16658 {
16659 PyThreadState* __tstate = wxPyBeginAllowThreads();
16660 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16661 wxPyEndAllowThreads(__tstate);
16662 if (PyErr_Occurred()) SWIG_fail;
16663 }
16664 resultobj = SWIG_Py_Void();
16665 return resultobj;
16666 fail:
16667 return NULL;
16668 }
16669
16670
16671 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16672 PyObject *resultobj = 0;
16673 wxGrid *arg1 = (wxGrid *) 0 ;
16674 int arg2 ;
16675 int arg3 ;
16676 wxColour *arg4 = 0 ;
16677 void *argp1 = 0 ;
16678 int res1 = 0 ;
16679 int val2 ;
16680 int ecode2 = 0 ;
16681 int val3 ;
16682 int ecode3 = 0 ;
16683 wxColour temp4 ;
16684 PyObject * obj0 = 0 ;
16685 PyObject * obj1 = 0 ;
16686 PyObject * obj2 = 0 ;
16687 PyObject * obj3 = 0 ;
16688 char * kwnames[] = {
16689 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16690 };
16691
16692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16694 if (!SWIG_IsOK(res1)) {
16695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16696 }
16697 arg1 = reinterpret_cast< wxGrid * >(argp1);
16698 ecode2 = SWIG_AsVal_int(obj1, &val2);
16699 if (!SWIG_IsOK(ecode2)) {
16700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16701 }
16702 arg2 = static_cast< int >(val2);
16703 ecode3 = SWIG_AsVal_int(obj2, &val3);
16704 if (!SWIG_IsOK(ecode3)) {
16705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16706 }
16707 arg3 = static_cast< int >(val3);
16708 {
16709 arg4 = &temp4;
16710 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16711 }
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 resultobj = SWIG_Py_Void();
16719 return resultobj;
16720 fail:
16721 return NULL;
16722 }
16723
16724
16725 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16726 PyObject *resultobj = 0;
16727 wxGrid *arg1 = (wxGrid *) 0 ;
16728 wxFont *arg2 = 0 ;
16729 void *argp1 = 0 ;
16730 int res1 = 0 ;
16731 void *argp2 = 0 ;
16732 int res2 = 0 ;
16733 PyObject * obj0 = 0 ;
16734 PyObject * obj1 = 0 ;
16735 char * kwnames[] = {
16736 (char *) "self",(char *)"arg2", NULL
16737 };
16738
16739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16741 if (!SWIG_IsOK(res1)) {
16742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16743 }
16744 arg1 = reinterpret_cast< wxGrid * >(argp1);
16745 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16746 if (!SWIG_IsOK(res2)) {
16747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16748 }
16749 if (!argp2) {
16750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16751 }
16752 arg2 = reinterpret_cast< wxFont * >(argp2);
16753 {
16754 PyThreadState* __tstate = wxPyBeginAllowThreads();
16755 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16756 wxPyEndAllowThreads(__tstate);
16757 if (PyErr_Occurred()) SWIG_fail;
16758 }
16759 resultobj = SWIG_Py_Void();
16760 return resultobj;
16761 fail:
16762 return NULL;
16763 }
16764
16765
16766 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16767 PyObject *resultobj = 0;
16768 wxGrid *arg1 = (wxGrid *) 0 ;
16769 int arg2 ;
16770 int arg3 ;
16771 wxFont *arg4 = 0 ;
16772 void *argp1 = 0 ;
16773 int res1 = 0 ;
16774 int val2 ;
16775 int ecode2 = 0 ;
16776 int val3 ;
16777 int ecode3 = 0 ;
16778 void *argp4 = 0 ;
16779 int res4 = 0 ;
16780 PyObject * obj0 = 0 ;
16781 PyObject * obj1 = 0 ;
16782 PyObject * obj2 = 0 ;
16783 PyObject * obj3 = 0 ;
16784 char * kwnames[] = {
16785 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16786 };
16787
16788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16790 if (!SWIG_IsOK(res1)) {
16791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16792 }
16793 arg1 = reinterpret_cast< wxGrid * >(argp1);
16794 ecode2 = SWIG_AsVal_int(obj1, &val2);
16795 if (!SWIG_IsOK(ecode2)) {
16796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16797 }
16798 arg2 = static_cast< int >(val2);
16799 ecode3 = SWIG_AsVal_int(obj2, &val3);
16800 if (!SWIG_IsOK(ecode3)) {
16801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16802 }
16803 arg3 = static_cast< int >(val3);
16804 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16805 if (!SWIG_IsOK(res4)) {
16806 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16807 }
16808 if (!argp4) {
16809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16810 }
16811 arg4 = reinterpret_cast< wxFont * >(argp4);
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 resultobj = SWIG_Py_Void();
16819 return resultobj;
16820 fail:
16821 return NULL;
16822 }
16823
16824
16825 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj = 0;
16827 wxGrid *arg1 = (wxGrid *) 0 ;
16828 int arg2 ;
16829 int arg3 ;
16830 void *argp1 = 0 ;
16831 int res1 = 0 ;
16832 int val2 ;
16833 int ecode2 = 0 ;
16834 int val3 ;
16835 int ecode3 = 0 ;
16836 PyObject * obj0 = 0 ;
16837 PyObject * obj1 = 0 ;
16838 PyObject * obj2 = 0 ;
16839 char * kwnames[] = {
16840 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16841 };
16842
16843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16845 if (!SWIG_IsOK(res1)) {
16846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16847 }
16848 arg1 = reinterpret_cast< wxGrid * >(argp1);
16849 ecode2 = SWIG_AsVal_int(obj1, &val2);
16850 if (!SWIG_IsOK(ecode2)) {
16851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16852 }
16853 arg2 = static_cast< int >(val2);
16854 ecode3 = SWIG_AsVal_int(obj2, &val3);
16855 if (!SWIG_IsOK(ecode3)) {
16856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16857 }
16858 arg3 = static_cast< int >(val3);
16859 {
16860 PyThreadState* __tstate = wxPyBeginAllowThreads();
16861 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16862 wxPyEndAllowThreads(__tstate);
16863 if (PyErr_Occurred()) SWIG_fail;
16864 }
16865 resultobj = SWIG_Py_Void();
16866 return resultobj;
16867 fail:
16868 return NULL;
16869 }
16870
16871
16872 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16873 PyObject *resultobj = 0;
16874 wxGrid *arg1 = (wxGrid *) 0 ;
16875 int arg2 ;
16876 int arg3 ;
16877 int arg4 ;
16878 int arg5 ;
16879 void *argp1 = 0 ;
16880 int res1 = 0 ;
16881 int val2 ;
16882 int ecode2 = 0 ;
16883 int val3 ;
16884 int ecode3 = 0 ;
16885 int val4 ;
16886 int ecode4 = 0 ;
16887 int val5 ;
16888 int ecode5 = 0 ;
16889 PyObject * obj0 = 0 ;
16890 PyObject * obj1 = 0 ;
16891 PyObject * obj2 = 0 ;
16892 PyObject * obj3 = 0 ;
16893 PyObject * obj4 = 0 ;
16894 char * kwnames[] = {
16895 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16896 };
16897
16898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16900 if (!SWIG_IsOK(res1)) {
16901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16902 }
16903 arg1 = reinterpret_cast< wxGrid * >(argp1);
16904 ecode2 = SWIG_AsVal_int(obj1, &val2);
16905 if (!SWIG_IsOK(ecode2)) {
16906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16907 }
16908 arg2 = static_cast< int >(val2);
16909 ecode3 = SWIG_AsVal_int(obj2, &val3);
16910 if (!SWIG_IsOK(ecode3)) {
16911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16912 }
16913 arg3 = static_cast< int >(val3);
16914 ecode4 = SWIG_AsVal_int(obj3, &val4);
16915 if (!SWIG_IsOK(ecode4)) {
16916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16917 }
16918 arg4 = static_cast< int >(val4);
16919 ecode5 = SWIG_AsVal_int(obj4, &val5);
16920 if (!SWIG_IsOK(ecode5)) {
16921 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16922 }
16923 arg5 = static_cast< int >(val5);
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 resultobj = SWIG_Py_Void();
16931 return resultobj;
16932 fail:
16933 return NULL;
16934 }
16935
16936
16937 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16938 PyObject *resultobj = 0;
16939 wxGrid *arg1 = (wxGrid *) 0 ;
16940 bool arg2 ;
16941 void *argp1 = 0 ;
16942 int res1 = 0 ;
16943 bool val2 ;
16944 int ecode2 = 0 ;
16945 PyObject * obj0 = 0 ;
16946 PyObject * obj1 = 0 ;
16947 char * kwnames[] = {
16948 (char *) "self",(char *) "allow", NULL
16949 };
16950
16951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16953 if (!SWIG_IsOK(res1)) {
16954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16955 }
16956 arg1 = reinterpret_cast< wxGrid * >(argp1);
16957 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16958 if (!SWIG_IsOK(ecode2)) {
16959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16960 }
16961 arg2 = static_cast< bool >(val2);
16962 {
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 (arg1)->SetDefaultCellOverflow(arg2);
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 resultobj = SWIG_Py_Void();
16969 return resultobj;
16970 fail:
16971 return NULL;
16972 }
16973
16974
16975 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16976 PyObject *resultobj = 0;
16977 wxGrid *arg1 = (wxGrid *) 0 ;
16978 int arg2 ;
16979 int arg3 ;
16980 bool arg4 ;
16981 void *argp1 = 0 ;
16982 int res1 = 0 ;
16983 int val2 ;
16984 int ecode2 = 0 ;
16985 int val3 ;
16986 int ecode3 = 0 ;
16987 bool val4 ;
16988 int ecode4 = 0 ;
16989 PyObject * obj0 = 0 ;
16990 PyObject * obj1 = 0 ;
16991 PyObject * obj2 = 0 ;
16992 PyObject * obj3 = 0 ;
16993 char * kwnames[] = {
16994 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16995 };
16996
16997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16999 if (!SWIG_IsOK(res1)) {
17000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
17001 }
17002 arg1 = reinterpret_cast< wxGrid * >(argp1);
17003 ecode2 = SWIG_AsVal_int(obj1, &val2);
17004 if (!SWIG_IsOK(ecode2)) {
17005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
17006 }
17007 arg2 = static_cast< int >(val2);
17008 ecode3 = SWIG_AsVal_int(obj2, &val3);
17009 if (!SWIG_IsOK(ecode3)) {
17010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
17011 }
17012 arg3 = static_cast< int >(val3);
17013 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17014 if (!SWIG_IsOK(ecode4)) {
17015 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
17016 }
17017 arg4 = static_cast< bool >(val4);
17018 {
17019 PyThreadState* __tstate = wxPyBeginAllowThreads();
17020 (arg1)->SetCellOverflow(arg2,arg3,arg4);
17021 wxPyEndAllowThreads(__tstate);
17022 if (PyErr_Occurred()) SWIG_fail;
17023 }
17024 resultobj = SWIG_Py_Void();
17025 return resultobj;
17026 fail:
17027 return NULL;
17028 }
17029
17030
17031 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17032 PyObject *resultobj = 0;
17033 wxGrid *arg1 = (wxGrid *) 0 ;
17034 int arg2 ;
17035 int arg3 ;
17036 int arg4 ;
17037 int arg5 ;
17038 void *argp1 = 0 ;
17039 int res1 = 0 ;
17040 int val2 ;
17041 int ecode2 = 0 ;
17042 int val3 ;
17043 int ecode3 = 0 ;
17044 int val4 ;
17045 int ecode4 = 0 ;
17046 int val5 ;
17047 int ecode5 = 0 ;
17048 PyObject * obj0 = 0 ;
17049 PyObject * obj1 = 0 ;
17050 PyObject * obj2 = 0 ;
17051 PyObject * obj3 = 0 ;
17052 PyObject * obj4 = 0 ;
17053 char * kwnames[] = {
17054 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
17055 };
17056
17057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17059 if (!SWIG_IsOK(res1)) {
17060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
17061 }
17062 arg1 = reinterpret_cast< wxGrid * >(argp1);
17063 ecode2 = SWIG_AsVal_int(obj1, &val2);
17064 if (!SWIG_IsOK(ecode2)) {
17065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
17066 }
17067 arg2 = static_cast< int >(val2);
17068 ecode3 = SWIG_AsVal_int(obj2, &val3);
17069 if (!SWIG_IsOK(ecode3)) {
17070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
17071 }
17072 arg3 = static_cast< int >(val3);
17073 ecode4 = SWIG_AsVal_int(obj3, &val4);
17074 if (!SWIG_IsOK(ecode4)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
17076 }
17077 arg4 = static_cast< int >(val4);
17078 ecode5 = SWIG_AsVal_int(obj4, &val5);
17079 if (!SWIG_IsOK(ecode5)) {
17080 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
17081 }
17082 arg5 = static_cast< int >(val5);
17083 {
17084 PyThreadState* __tstate = wxPyBeginAllowThreads();
17085 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 resultobj = SWIG_Py_Void();
17090 return resultobj;
17091 fail:
17092 return NULL;
17093 }
17094
17095
17096 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17097 PyObject *resultobj = 0;
17098 wxGrid *arg1 = (wxGrid *) 0 ;
17099 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
17100 void *argp1 = 0 ;
17101 int res1 = 0 ;
17102 void *argp2 = 0 ;
17103 int res2 = 0 ;
17104 PyObject * obj0 = 0 ;
17105 PyObject * obj1 = 0 ;
17106 char * kwnames[] = {
17107 (char *) "self",(char *) "renderer", NULL
17108 };
17109
17110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
17111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17112 if (!SWIG_IsOK(res1)) {
17113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17114 }
17115 arg1 = reinterpret_cast< wxGrid * >(argp1);
17116 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17117 if (!SWIG_IsOK(res2)) {
17118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
17119 }
17120 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 (arg1)->SetDefaultRenderer(arg2);
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 resultobj = SWIG_Py_Void();
17128 return resultobj;
17129 fail:
17130 return NULL;
17131 }
17132
17133
17134 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17135 PyObject *resultobj = 0;
17136 wxGrid *arg1 = (wxGrid *) 0 ;
17137 int arg2 ;
17138 int arg3 ;
17139 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
17140 void *argp1 = 0 ;
17141 int res1 = 0 ;
17142 int val2 ;
17143 int ecode2 = 0 ;
17144 int val3 ;
17145 int ecode3 = 0 ;
17146 void *argp4 = 0 ;
17147 int res4 = 0 ;
17148 PyObject * obj0 = 0 ;
17149 PyObject * obj1 = 0 ;
17150 PyObject * obj2 = 0 ;
17151 PyObject * obj3 = 0 ;
17152 char * kwnames[] = {
17153 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
17154 };
17155
17156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17158 if (!SWIG_IsOK(res1)) {
17159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17160 }
17161 arg1 = reinterpret_cast< wxGrid * >(argp1);
17162 ecode2 = SWIG_AsVal_int(obj1, &val2);
17163 if (!SWIG_IsOK(ecode2)) {
17164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17165 }
17166 arg2 = static_cast< int >(val2);
17167 ecode3 = SWIG_AsVal_int(obj2, &val3);
17168 if (!SWIG_IsOK(ecode3)) {
17169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17170 }
17171 arg3 = static_cast< int >(val3);
17172 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17173 if (!SWIG_IsOK(res4)) {
17174 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
17175 }
17176 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
17177 {
17178 PyThreadState* __tstate = wxPyBeginAllowThreads();
17179 (arg1)->SetCellRenderer(arg2,arg3,arg4);
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 resultobj = SWIG_Py_Void();
17184 return resultobj;
17185 fail:
17186 return NULL;
17187 }
17188
17189
17190 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17191 PyObject *resultobj = 0;
17192 wxGrid *arg1 = (wxGrid *) 0 ;
17193 wxGridCellRenderer *result = 0 ;
17194 void *argp1 = 0 ;
17195 int res1 = 0 ;
17196 PyObject *swig_obj[1] ;
17197
17198 if (!args) SWIG_fail;
17199 swig_obj[0] = args;
17200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17201 if (!SWIG_IsOK(res1)) {
17202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
17203 }
17204 arg1 = reinterpret_cast< wxGrid * >(argp1);
17205 {
17206 PyThreadState* __tstate = wxPyBeginAllowThreads();
17207 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
17208 wxPyEndAllowThreads(__tstate);
17209 if (PyErr_Occurred()) SWIG_fail;
17210 }
17211 {
17212 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17213 }
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17221 PyObject *resultobj = 0;
17222 wxGrid *arg1 = (wxGrid *) 0 ;
17223 int arg2 ;
17224 int arg3 ;
17225 wxGridCellRenderer *result = 0 ;
17226 void *argp1 = 0 ;
17227 int res1 = 0 ;
17228 int val2 ;
17229 int ecode2 = 0 ;
17230 int val3 ;
17231 int ecode3 = 0 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 PyObject * obj2 = 0 ;
17235 char * kwnames[] = {
17236 (char *) "self",(char *) "row",(char *) "col", NULL
17237 };
17238
17239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17241 if (!SWIG_IsOK(res1)) {
17242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17243 }
17244 arg1 = reinterpret_cast< wxGrid * >(argp1);
17245 ecode2 = SWIG_AsVal_int(obj1, &val2);
17246 if (!SWIG_IsOK(ecode2)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17248 }
17249 arg2 = static_cast< int >(val2);
17250 ecode3 = SWIG_AsVal_int(obj2, &val3);
17251 if (!SWIG_IsOK(ecode3)) {
17252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17253 }
17254 arg3 = static_cast< int >(val3);
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj = 0;
17272 wxGrid *arg1 = (wxGrid *) 0 ;
17273 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17274 void *argp1 = 0 ;
17275 int res1 = 0 ;
17276 void *argp2 = 0 ;
17277 int res2 = 0 ;
17278 PyObject * obj0 = 0 ;
17279 PyObject * obj1 = 0 ;
17280 char * kwnames[] = {
17281 (char *) "self",(char *) "editor", NULL
17282 };
17283
17284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17286 if (!SWIG_IsOK(res1)) {
17287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17288 }
17289 arg1 = reinterpret_cast< wxGrid * >(argp1);
17290 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17291 if (!SWIG_IsOK(res2)) {
17292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17293 }
17294 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 (arg1)->SetDefaultEditor(arg2);
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 resultobj = SWIG_Py_Void();
17302 return resultobj;
17303 fail:
17304 return NULL;
17305 }
17306
17307
17308 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17309 PyObject *resultobj = 0;
17310 wxGrid *arg1 = (wxGrid *) 0 ;
17311 int arg2 ;
17312 int arg3 ;
17313 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17314 void *argp1 = 0 ;
17315 int res1 = 0 ;
17316 int val2 ;
17317 int ecode2 = 0 ;
17318 int val3 ;
17319 int ecode3 = 0 ;
17320 void *argp4 = 0 ;
17321 int res4 = 0 ;
17322 PyObject * obj0 = 0 ;
17323 PyObject * obj1 = 0 ;
17324 PyObject * obj2 = 0 ;
17325 PyObject * obj3 = 0 ;
17326 char * kwnames[] = {
17327 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17328 };
17329
17330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17332 if (!SWIG_IsOK(res1)) {
17333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17334 }
17335 arg1 = reinterpret_cast< wxGrid * >(argp1);
17336 ecode2 = SWIG_AsVal_int(obj1, &val2);
17337 if (!SWIG_IsOK(ecode2)) {
17338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17339 }
17340 arg2 = static_cast< int >(val2);
17341 ecode3 = SWIG_AsVal_int(obj2, &val3);
17342 if (!SWIG_IsOK(ecode3)) {
17343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17344 }
17345 arg3 = static_cast< int >(val3);
17346 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17347 if (!SWIG_IsOK(res4)) {
17348 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17349 }
17350 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 (arg1)->SetCellEditor(arg2,arg3,arg4);
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = SWIG_Py_Void();
17358 return resultobj;
17359 fail:
17360 return NULL;
17361 }
17362
17363
17364 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17365 PyObject *resultobj = 0;
17366 wxGrid *arg1 = (wxGrid *) 0 ;
17367 wxGridCellEditor *result = 0 ;
17368 void *argp1 = 0 ;
17369 int res1 = 0 ;
17370 PyObject *swig_obj[1] ;
17371
17372 if (!args) SWIG_fail;
17373 swig_obj[0] = args;
17374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17375 if (!SWIG_IsOK(res1)) {
17376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17377 }
17378 arg1 = reinterpret_cast< wxGrid * >(argp1);
17379 {
17380 PyThreadState* __tstate = wxPyBeginAllowThreads();
17381 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17382 wxPyEndAllowThreads(__tstate);
17383 if (PyErr_Occurred()) SWIG_fail;
17384 }
17385 {
17386 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17387 }
17388 return resultobj;
17389 fail:
17390 return NULL;
17391 }
17392
17393
17394 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17395 PyObject *resultobj = 0;
17396 wxGrid *arg1 = (wxGrid *) 0 ;
17397 int arg2 ;
17398 int arg3 ;
17399 wxGridCellEditor *result = 0 ;
17400 void *argp1 = 0 ;
17401 int res1 = 0 ;
17402 int val2 ;
17403 int ecode2 = 0 ;
17404 int val3 ;
17405 int ecode3 = 0 ;
17406 PyObject * obj0 = 0 ;
17407 PyObject * obj1 = 0 ;
17408 PyObject * obj2 = 0 ;
17409 char * kwnames[] = {
17410 (char *) "self",(char *) "row",(char *) "col", NULL
17411 };
17412
17413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17415 if (!SWIG_IsOK(res1)) {
17416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17417 }
17418 arg1 = reinterpret_cast< wxGrid * >(argp1);
17419 ecode2 = SWIG_AsVal_int(obj1, &val2);
17420 if (!SWIG_IsOK(ecode2)) {
17421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17422 }
17423 arg2 = static_cast< int >(val2);
17424 ecode3 = SWIG_AsVal_int(obj2, &val3);
17425 if (!SWIG_IsOK(ecode3)) {
17426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17427 }
17428 arg3 = static_cast< int >(val3);
17429 {
17430 PyThreadState* __tstate = wxPyBeginAllowThreads();
17431 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 {
17436 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17437 }
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17445 PyObject *resultobj = 0;
17446 wxGrid *arg1 = (wxGrid *) 0 ;
17447 int arg2 ;
17448 int arg3 ;
17449 wxString result;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 int val2 ;
17453 int ecode2 = 0 ;
17454 int val3 ;
17455 int ecode3 = 0 ;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 PyObject * obj2 = 0 ;
17459 char * kwnames[] = {
17460 (char *) "self",(char *) "row",(char *) "col", NULL
17461 };
17462
17463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17465 if (!SWIG_IsOK(res1)) {
17466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17467 }
17468 arg1 = reinterpret_cast< wxGrid * >(argp1);
17469 ecode2 = SWIG_AsVal_int(obj1, &val2);
17470 if (!SWIG_IsOK(ecode2)) {
17471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17472 }
17473 arg2 = static_cast< int >(val2);
17474 ecode3 = SWIG_AsVal_int(obj2, &val3);
17475 if (!SWIG_IsOK(ecode3)) {
17476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17477 }
17478 arg3 = static_cast< int >(val3);
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (arg1)->GetCellValue(arg2,arg3);
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 {
17486 #if wxUSE_UNICODE
17487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17488 #else
17489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17490 #endif
17491 }
17492 return resultobj;
17493 fail:
17494 return NULL;
17495 }
17496
17497
17498 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj = 0;
17500 wxGrid *arg1 = (wxGrid *) 0 ;
17501 int arg2 ;
17502 int arg3 ;
17503 wxString *arg4 = 0 ;
17504 void *argp1 = 0 ;
17505 int res1 = 0 ;
17506 int val2 ;
17507 int ecode2 = 0 ;
17508 int val3 ;
17509 int ecode3 = 0 ;
17510 bool temp4 = false ;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 PyObject * obj2 = 0 ;
17514 PyObject * obj3 = 0 ;
17515 char * kwnames[] = {
17516 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17517 };
17518
17519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17521 if (!SWIG_IsOK(res1)) {
17522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17523 }
17524 arg1 = reinterpret_cast< wxGrid * >(argp1);
17525 ecode2 = SWIG_AsVal_int(obj1, &val2);
17526 if (!SWIG_IsOK(ecode2)) {
17527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17528 }
17529 arg2 = static_cast< int >(val2);
17530 ecode3 = SWIG_AsVal_int(obj2, &val3);
17531 if (!SWIG_IsOK(ecode3)) {
17532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17533 }
17534 arg3 = static_cast< int >(val3);
17535 {
17536 arg4 = wxString_in_helper(obj3);
17537 if (arg4 == NULL) SWIG_fail;
17538 temp4 = true;
17539 }
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17543 wxPyEndAllowThreads(__tstate);
17544 if (PyErr_Occurred()) SWIG_fail;
17545 }
17546 resultobj = SWIG_Py_Void();
17547 {
17548 if (temp4)
17549 delete arg4;
17550 }
17551 return resultobj;
17552 fail:
17553 {
17554 if (temp4)
17555 delete arg4;
17556 }
17557 return NULL;
17558 }
17559
17560
17561 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17562 PyObject *resultobj = 0;
17563 wxGrid *arg1 = (wxGrid *) 0 ;
17564 int arg2 ;
17565 int arg3 ;
17566 bool result;
17567 void *argp1 = 0 ;
17568 int res1 = 0 ;
17569 int val2 ;
17570 int ecode2 = 0 ;
17571 int val3 ;
17572 int ecode3 = 0 ;
17573 PyObject * obj0 = 0 ;
17574 PyObject * obj1 = 0 ;
17575 PyObject * obj2 = 0 ;
17576 char * kwnames[] = {
17577 (char *) "self",(char *) "row",(char *) "col", NULL
17578 };
17579
17580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17582 if (!SWIG_IsOK(res1)) {
17583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17584 }
17585 arg1 = reinterpret_cast< wxGrid * >(argp1);
17586 ecode2 = SWIG_AsVal_int(obj1, &val2);
17587 if (!SWIG_IsOK(ecode2)) {
17588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17589 }
17590 arg2 = static_cast< int >(val2);
17591 ecode3 = SWIG_AsVal_int(obj2, &val3);
17592 if (!SWIG_IsOK(ecode3)) {
17593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17594 }
17595 arg3 = static_cast< int >(val3);
17596 {
17597 PyThreadState* __tstate = wxPyBeginAllowThreads();
17598 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17599 wxPyEndAllowThreads(__tstate);
17600 if (PyErr_Occurred()) SWIG_fail;
17601 }
17602 {
17603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17604 }
17605 return resultobj;
17606 fail:
17607 return NULL;
17608 }
17609
17610
17611 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17612 PyObject *resultobj = 0;
17613 wxGrid *arg1 = (wxGrid *) 0 ;
17614 int arg2 ;
17615 int arg3 ;
17616 bool arg4 = (bool) true ;
17617 void *argp1 = 0 ;
17618 int res1 = 0 ;
17619 int val2 ;
17620 int ecode2 = 0 ;
17621 int val3 ;
17622 int ecode3 = 0 ;
17623 bool val4 ;
17624 int ecode4 = 0 ;
17625 PyObject * obj0 = 0 ;
17626 PyObject * obj1 = 0 ;
17627 PyObject * obj2 = 0 ;
17628 PyObject * obj3 = 0 ;
17629 char * kwnames[] = {
17630 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17631 };
17632
17633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17635 if (!SWIG_IsOK(res1)) {
17636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17637 }
17638 arg1 = reinterpret_cast< wxGrid * >(argp1);
17639 ecode2 = SWIG_AsVal_int(obj1, &val2);
17640 if (!SWIG_IsOK(ecode2)) {
17641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17642 }
17643 arg2 = static_cast< int >(val2);
17644 ecode3 = SWIG_AsVal_int(obj2, &val3);
17645 if (!SWIG_IsOK(ecode3)) {
17646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17647 }
17648 arg3 = static_cast< int >(val3);
17649 if (obj3) {
17650 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17651 if (!SWIG_IsOK(ecode4)) {
17652 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17653 }
17654 arg4 = static_cast< bool >(val4);
17655 }
17656 {
17657 PyThreadState* __tstate = wxPyBeginAllowThreads();
17658 (arg1)->SetReadOnly(arg2,arg3,arg4);
17659 wxPyEndAllowThreads(__tstate);
17660 if (PyErr_Occurred()) SWIG_fail;
17661 }
17662 resultobj = SWIG_Py_Void();
17663 return resultobj;
17664 fail:
17665 return NULL;
17666 }
17667
17668
17669 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17670 PyObject *resultobj = 0;
17671 wxGrid *arg1 = (wxGrid *) 0 ;
17672 int arg2 ;
17673 bool arg3 = (bool) false ;
17674 void *argp1 = 0 ;
17675 int res1 = 0 ;
17676 int val2 ;
17677 int ecode2 = 0 ;
17678 bool val3 ;
17679 int ecode3 = 0 ;
17680 PyObject * obj0 = 0 ;
17681 PyObject * obj1 = 0 ;
17682 PyObject * obj2 = 0 ;
17683 char * kwnames[] = {
17684 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17685 };
17686
17687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17689 if (!SWIG_IsOK(res1)) {
17690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17691 }
17692 arg1 = reinterpret_cast< wxGrid * >(argp1);
17693 ecode2 = SWIG_AsVal_int(obj1, &val2);
17694 if (!SWIG_IsOK(ecode2)) {
17695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17696 }
17697 arg2 = static_cast< int >(val2);
17698 if (obj2) {
17699 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17700 if (!SWIG_IsOK(ecode3)) {
17701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17702 }
17703 arg3 = static_cast< bool >(val3);
17704 }
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 (arg1)->SelectRow(arg2,arg3);
17708 wxPyEndAllowThreads(__tstate);
17709 if (PyErr_Occurred()) SWIG_fail;
17710 }
17711 resultobj = SWIG_Py_Void();
17712 return resultobj;
17713 fail:
17714 return NULL;
17715 }
17716
17717
17718 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj = 0;
17720 wxGrid *arg1 = (wxGrid *) 0 ;
17721 int arg2 ;
17722 bool arg3 = (bool) false ;
17723 void *argp1 = 0 ;
17724 int res1 = 0 ;
17725 int val2 ;
17726 int ecode2 = 0 ;
17727 bool val3 ;
17728 int ecode3 = 0 ;
17729 PyObject * obj0 = 0 ;
17730 PyObject * obj1 = 0 ;
17731 PyObject * obj2 = 0 ;
17732 char * kwnames[] = {
17733 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17734 };
17735
17736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17738 if (!SWIG_IsOK(res1)) {
17739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17740 }
17741 arg1 = reinterpret_cast< wxGrid * >(argp1);
17742 ecode2 = SWIG_AsVal_int(obj1, &val2);
17743 if (!SWIG_IsOK(ecode2)) {
17744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17745 }
17746 arg2 = static_cast< int >(val2);
17747 if (obj2) {
17748 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17749 if (!SWIG_IsOK(ecode3)) {
17750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17751 }
17752 arg3 = static_cast< bool >(val3);
17753 }
17754 {
17755 PyThreadState* __tstate = wxPyBeginAllowThreads();
17756 (arg1)->SelectCol(arg2,arg3);
17757 wxPyEndAllowThreads(__tstate);
17758 if (PyErr_Occurred()) SWIG_fail;
17759 }
17760 resultobj = SWIG_Py_Void();
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj = 0;
17769 wxGrid *arg1 = (wxGrid *) 0 ;
17770 int arg2 ;
17771 int arg3 ;
17772 int arg4 ;
17773 int arg5 ;
17774 bool arg6 = (bool) false ;
17775 void *argp1 = 0 ;
17776 int res1 = 0 ;
17777 int val2 ;
17778 int ecode2 = 0 ;
17779 int val3 ;
17780 int ecode3 = 0 ;
17781 int val4 ;
17782 int ecode4 = 0 ;
17783 int val5 ;
17784 int ecode5 = 0 ;
17785 bool val6 ;
17786 int ecode6 = 0 ;
17787 PyObject * obj0 = 0 ;
17788 PyObject * obj1 = 0 ;
17789 PyObject * obj2 = 0 ;
17790 PyObject * obj3 = 0 ;
17791 PyObject * obj4 = 0 ;
17792 PyObject * obj5 = 0 ;
17793 char * kwnames[] = {
17794 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17795 };
17796
17797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17799 if (!SWIG_IsOK(res1)) {
17800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17801 }
17802 arg1 = reinterpret_cast< wxGrid * >(argp1);
17803 ecode2 = SWIG_AsVal_int(obj1, &val2);
17804 if (!SWIG_IsOK(ecode2)) {
17805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17806 }
17807 arg2 = static_cast< int >(val2);
17808 ecode3 = SWIG_AsVal_int(obj2, &val3);
17809 if (!SWIG_IsOK(ecode3)) {
17810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17811 }
17812 arg3 = static_cast< int >(val3);
17813 ecode4 = SWIG_AsVal_int(obj3, &val4);
17814 if (!SWIG_IsOK(ecode4)) {
17815 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17816 }
17817 arg4 = static_cast< int >(val4);
17818 ecode5 = SWIG_AsVal_int(obj4, &val5);
17819 if (!SWIG_IsOK(ecode5)) {
17820 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17821 }
17822 arg5 = static_cast< int >(val5);
17823 if (obj5) {
17824 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17825 if (!SWIG_IsOK(ecode6)) {
17826 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17827 }
17828 arg6 = static_cast< bool >(val6);
17829 }
17830 {
17831 PyThreadState* __tstate = wxPyBeginAllowThreads();
17832 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 resultobj = SWIG_Py_Void();
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17844 PyObject *resultobj = 0;
17845 wxGrid *arg1 = (wxGrid *) 0 ;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17855 }
17856 arg1 = reinterpret_cast< wxGrid * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 (arg1)->SelectAll();
17860 wxPyEndAllowThreads(__tstate);
17861 if (PyErr_Occurred()) SWIG_fail;
17862 }
17863 resultobj = SWIG_Py_Void();
17864 return resultobj;
17865 fail:
17866 return NULL;
17867 }
17868
17869
17870 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17871 PyObject *resultobj = 0;
17872 wxGrid *arg1 = (wxGrid *) 0 ;
17873 bool result;
17874 void *argp1 = 0 ;
17875 int res1 = 0 ;
17876 PyObject *swig_obj[1] ;
17877
17878 if (!args) SWIG_fail;
17879 swig_obj[0] = args;
17880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17881 if (!SWIG_IsOK(res1)) {
17882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17883 }
17884 arg1 = reinterpret_cast< wxGrid * >(argp1);
17885 {
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 result = (bool)(arg1)->IsSelection();
17888 wxPyEndAllowThreads(__tstate);
17889 if (PyErr_Occurred()) SWIG_fail;
17890 }
17891 {
17892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17893 }
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17901 PyObject *resultobj = 0;
17902 wxGrid *arg1 = (wxGrid *) 0 ;
17903 void *argp1 = 0 ;
17904 int res1 = 0 ;
17905 PyObject *swig_obj[1] ;
17906
17907 if (!args) SWIG_fail;
17908 swig_obj[0] = args;
17909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17910 if (!SWIG_IsOK(res1)) {
17911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17912 }
17913 arg1 = reinterpret_cast< wxGrid * >(argp1);
17914 {
17915 PyThreadState* __tstate = wxPyBeginAllowThreads();
17916 (arg1)->ClearSelection();
17917 wxPyEndAllowThreads(__tstate);
17918 if (PyErr_Occurred()) SWIG_fail;
17919 }
17920 resultobj = SWIG_Py_Void();
17921 return resultobj;
17922 fail:
17923 return NULL;
17924 }
17925
17926
17927 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17928 PyObject *resultobj = 0;
17929 wxGrid *arg1 = (wxGrid *) 0 ;
17930 int arg2 ;
17931 int arg3 ;
17932 bool result;
17933 void *argp1 = 0 ;
17934 int res1 = 0 ;
17935 int val2 ;
17936 int ecode2 = 0 ;
17937 int val3 ;
17938 int ecode3 = 0 ;
17939 PyObject * obj0 = 0 ;
17940 PyObject * obj1 = 0 ;
17941 PyObject * obj2 = 0 ;
17942 char * kwnames[] = {
17943 (char *) "self",(char *) "row",(char *) "col", NULL
17944 };
17945
17946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17948 if (!SWIG_IsOK(res1)) {
17949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17950 }
17951 arg1 = reinterpret_cast< wxGrid * >(argp1);
17952 ecode2 = SWIG_AsVal_int(obj1, &val2);
17953 if (!SWIG_IsOK(ecode2)) {
17954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17955 }
17956 arg2 = static_cast< int >(val2);
17957 ecode3 = SWIG_AsVal_int(obj2, &val3);
17958 if (!SWIG_IsOK(ecode3)) {
17959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17960 }
17961 arg3 = static_cast< int >(val3);
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17965 wxPyEndAllowThreads(__tstate);
17966 if (PyErr_Occurred()) SWIG_fail;
17967 }
17968 {
17969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17970 }
17971 return resultobj;
17972 fail:
17973 return NULL;
17974 }
17975
17976
17977 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17978 PyObject *resultobj = 0;
17979 wxGrid *arg1 = (wxGrid *) 0 ;
17980 wxGridCellCoordsArray result;
17981 void *argp1 = 0 ;
17982 int res1 = 0 ;
17983 PyObject *swig_obj[1] ;
17984
17985 if (!args) SWIG_fail;
17986 swig_obj[0] = args;
17987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17988 if (!SWIG_IsOK(res1)) {
17989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17990 }
17991 arg1 = reinterpret_cast< wxGrid * >(argp1);
17992 {
17993 PyThreadState* __tstate = wxPyBeginAllowThreads();
17994 result = ((wxGrid const *)arg1)->GetSelectedCells();
17995 wxPyEndAllowThreads(__tstate);
17996 if (PyErr_Occurred()) SWIG_fail;
17997 }
17998 {
17999 resultobj = wxGridCellCoordsArray_helper(result);
18000 }
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18008 PyObject *resultobj = 0;
18009 wxGrid *arg1 = (wxGrid *) 0 ;
18010 wxGridCellCoordsArray result;
18011 void *argp1 = 0 ;
18012 int res1 = 0 ;
18013 PyObject *swig_obj[1] ;
18014
18015 if (!args) SWIG_fail;
18016 swig_obj[0] = args;
18017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18018 if (!SWIG_IsOK(res1)) {
18019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
18020 }
18021 arg1 = reinterpret_cast< wxGrid * >(argp1);
18022 {
18023 PyThreadState* __tstate = wxPyBeginAllowThreads();
18024 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 {
18029 resultobj = wxGridCellCoordsArray_helper(result);
18030 }
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18038 PyObject *resultobj = 0;
18039 wxGrid *arg1 = (wxGrid *) 0 ;
18040 wxGridCellCoordsArray result;
18041 void *argp1 = 0 ;
18042 int res1 = 0 ;
18043 PyObject *swig_obj[1] ;
18044
18045 if (!args) SWIG_fail;
18046 swig_obj[0] = args;
18047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18048 if (!SWIG_IsOK(res1)) {
18049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
18050 }
18051 arg1 = reinterpret_cast< wxGrid * >(argp1);
18052 {
18053 PyThreadState* __tstate = wxPyBeginAllowThreads();
18054 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 {
18059 resultobj = wxGridCellCoordsArray_helper(result);
18060 }
18061 return resultobj;
18062 fail:
18063 return NULL;
18064 }
18065
18066
18067 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18068 PyObject *resultobj = 0;
18069 wxGrid *arg1 = (wxGrid *) 0 ;
18070 wxArrayInt result;
18071 void *argp1 = 0 ;
18072 int res1 = 0 ;
18073 PyObject *swig_obj[1] ;
18074
18075 if (!args) SWIG_fail;
18076 swig_obj[0] = args;
18077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18078 if (!SWIG_IsOK(res1)) {
18079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
18080 }
18081 arg1 = reinterpret_cast< wxGrid * >(argp1);
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = ((wxGrid const *)arg1)->GetSelectedRows();
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 {
18089 resultobj = wxArrayInt2PyList_helper(result);
18090 }
18091 return resultobj;
18092 fail:
18093 return NULL;
18094 }
18095
18096
18097 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18098 PyObject *resultobj = 0;
18099 wxGrid *arg1 = (wxGrid *) 0 ;
18100 wxArrayInt result;
18101 void *argp1 = 0 ;
18102 int res1 = 0 ;
18103 PyObject *swig_obj[1] ;
18104
18105 if (!args) SWIG_fail;
18106 swig_obj[0] = args;
18107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18108 if (!SWIG_IsOK(res1)) {
18109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
18110 }
18111 arg1 = reinterpret_cast< wxGrid * >(argp1);
18112 {
18113 PyThreadState* __tstate = wxPyBeginAllowThreads();
18114 result = ((wxGrid const *)arg1)->GetSelectedCols();
18115 wxPyEndAllowThreads(__tstate);
18116 if (PyErr_Occurred()) SWIG_fail;
18117 }
18118 {
18119 resultobj = wxArrayInt2PyList_helper(result);
18120 }
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18128 PyObject *resultobj = 0;
18129 wxGrid *arg1 = (wxGrid *) 0 ;
18130 int arg2 ;
18131 void *argp1 = 0 ;
18132 int res1 = 0 ;
18133 int val2 ;
18134 int ecode2 = 0 ;
18135 PyObject * obj0 = 0 ;
18136 PyObject * obj1 = 0 ;
18137 char * kwnames[] = {
18138 (char *) "self",(char *) "row", NULL
18139 };
18140
18141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
18142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18143 if (!SWIG_IsOK(res1)) {
18144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
18145 }
18146 arg1 = reinterpret_cast< wxGrid * >(argp1);
18147 ecode2 = SWIG_AsVal_int(obj1, &val2);
18148 if (!SWIG_IsOK(ecode2)) {
18149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
18150 }
18151 arg2 = static_cast< int >(val2);
18152 {
18153 PyThreadState* __tstate = wxPyBeginAllowThreads();
18154 (arg1)->DeselectRow(arg2);
18155 wxPyEndAllowThreads(__tstate);
18156 if (PyErr_Occurred()) SWIG_fail;
18157 }
18158 resultobj = SWIG_Py_Void();
18159 return resultobj;
18160 fail:
18161 return NULL;
18162 }
18163
18164
18165 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18166 PyObject *resultobj = 0;
18167 wxGrid *arg1 = (wxGrid *) 0 ;
18168 int arg2 ;
18169 void *argp1 = 0 ;
18170 int res1 = 0 ;
18171 int val2 ;
18172 int ecode2 = 0 ;
18173 PyObject * obj0 = 0 ;
18174 PyObject * obj1 = 0 ;
18175 char * kwnames[] = {
18176 (char *) "self",(char *) "col", NULL
18177 };
18178
18179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
18180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18181 if (!SWIG_IsOK(res1)) {
18182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
18183 }
18184 arg1 = reinterpret_cast< wxGrid * >(argp1);
18185 ecode2 = SWIG_AsVal_int(obj1, &val2);
18186 if (!SWIG_IsOK(ecode2)) {
18187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
18188 }
18189 arg2 = static_cast< int >(val2);
18190 {
18191 PyThreadState* __tstate = wxPyBeginAllowThreads();
18192 (arg1)->DeselectCol(arg2);
18193 wxPyEndAllowThreads(__tstate);
18194 if (PyErr_Occurred()) SWIG_fail;
18195 }
18196 resultobj = SWIG_Py_Void();
18197 return resultobj;
18198 fail:
18199 return NULL;
18200 }
18201
18202
18203 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18204 PyObject *resultobj = 0;
18205 wxGrid *arg1 = (wxGrid *) 0 ;
18206 int arg2 ;
18207 int arg3 ;
18208 void *argp1 = 0 ;
18209 int res1 = 0 ;
18210 int val2 ;
18211 int ecode2 = 0 ;
18212 int val3 ;
18213 int ecode3 = 0 ;
18214 PyObject * obj0 = 0 ;
18215 PyObject * obj1 = 0 ;
18216 PyObject * obj2 = 0 ;
18217 char * kwnames[] = {
18218 (char *) "self",(char *) "row",(char *) "col", NULL
18219 };
18220
18221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18223 if (!SWIG_IsOK(res1)) {
18224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
18225 }
18226 arg1 = reinterpret_cast< wxGrid * >(argp1);
18227 ecode2 = SWIG_AsVal_int(obj1, &val2);
18228 if (!SWIG_IsOK(ecode2)) {
18229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
18230 }
18231 arg2 = static_cast< int >(val2);
18232 ecode3 = SWIG_AsVal_int(obj2, &val3);
18233 if (!SWIG_IsOK(ecode3)) {
18234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
18235 }
18236 arg3 = static_cast< int >(val3);
18237 {
18238 PyThreadState* __tstate = wxPyBeginAllowThreads();
18239 (arg1)->DeselectCell(arg2,arg3);
18240 wxPyEndAllowThreads(__tstate);
18241 if (PyErr_Occurred()) SWIG_fail;
18242 }
18243 resultobj = SWIG_Py_Void();
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj = 0;
18252 wxGrid *arg1 = (wxGrid *) 0 ;
18253 wxGridCellCoords *arg2 = 0 ;
18254 wxGridCellCoords *arg3 = 0 ;
18255 wxRect result;
18256 void *argp1 = 0 ;
18257 int res1 = 0 ;
18258 wxGridCellCoords temp2 ;
18259 wxGridCellCoords temp3 ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 PyObject * obj2 = 0 ;
18263 char * kwnames[] = {
18264 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18265 };
18266
18267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18269 if (!SWIG_IsOK(res1)) {
18270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18271 }
18272 arg1 = reinterpret_cast< wxGrid * >(argp1);
18273 {
18274 arg2 = &temp2;
18275 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18276 }
18277 {
18278 arg3 = &temp3;
18279 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18280 }
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18295 PyObject *resultobj = 0;
18296 wxGrid *arg1 = (wxGrid *) 0 ;
18297 wxColour result;
18298 void *argp1 = 0 ;
18299 int res1 = 0 ;
18300 PyObject *swig_obj[1] ;
18301
18302 if (!args) SWIG_fail;
18303 swig_obj[0] = args;
18304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18305 if (!SWIG_IsOK(res1)) {
18306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18307 }
18308 arg1 = reinterpret_cast< wxGrid * >(argp1);
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18316 return resultobj;
18317 fail:
18318 return NULL;
18319 }
18320
18321
18322 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18323 PyObject *resultobj = 0;
18324 wxGrid *arg1 = (wxGrid *) 0 ;
18325 wxColour result;
18326 void *argp1 = 0 ;
18327 int res1 = 0 ;
18328 PyObject *swig_obj[1] ;
18329
18330 if (!args) SWIG_fail;
18331 swig_obj[0] = args;
18332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18333 if (!SWIG_IsOK(res1)) {
18334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18335 }
18336 arg1 = reinterpret_cast< wxGrid * >(argp1);
18337 {
18338 PyThreadState* __tstate = wxPyBeginAllowThreads();
18339 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18340 wxPyEndAllowThreads(__tstate);
18341 if (PyErr_Occurred()) SWIG_fail;
18342 }
18343 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18344 return resultobj;
18345 fail:
18346 return NULL;
18347 }
18348
18349
18350 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18351 PyObject *resultobj = 0;
18352 wxGrid *arg1 = (wxGrid *) 0 ;
18353 wxColour *arg2 = 0 ;
18354 void *argp1 = 0 ;
18355 int res1 = 0 ;
18356 wxColour temp2 ;
18357 PyObject * obj0 = 0 ;
18358 PyObject * obj1 = 0 ;
18359 char * kwnames[] = {
18360 (char *) "self",(char *) "c", NULL
18361 };
18362
18363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18365 if (!SWIG_IsOK(res1)) {
18366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18367 }
18368 arg1 = reinterpret_cast< wxGrid * >(argp1);
18369 {
18370 arg2 = &temp2;
18371 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18372 }
18373 {
18374 PyThreadState* __tstate = wxPyBeginAllowThreads();
18375 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18376 wxPyEndAllowThreads(__tstate);
18377 if (PyErr_Occurred()) SWIG_fail;
18378 }
18379 resultobj = SWIG_Py_Void();
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj = 0;
18388 wxGrid *arg1 = (wxGrid *) 0 ;
18389 wxColour *arg2 = 0 ;
18390 void *argp1 = 0 ;
18391 int res1 = 0 ;
18392 wxColour temp2 ;
18393 PyObject * obj0 = 0 ;
18394 PyObject * obj1 = 0 ;
18395 char * kwnames[] = {
18396 (char *) "self",(char *) "c", NULL
18397 };
18398
18399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18401 if (!SWIG_IsOK(res1)) {
18402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18403 }
18404 arg1 = reinterpret_cast< wxGrid * >(argp1);
18405 {
18406 arg2 = &temp2;
18407 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18408 }
18409 {
18410 PyThreadState* __tstate = wxPyBeginAllowThreads();
18411 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18412 wxPyEndAllowThreads(__tstate);
18413 if (PyErr_Occurred()) SWIG_fail;
18414 }
18415 resultobj = SWIG_Py_Void();
18416 return resultobj;
18417 fail:
18418 return NULL;
18419 }
18420
18421
18422 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj = 0;
18424 wxGrid *arg1 = (wxGrid *) 0 ;
18425 wxString *arg2 = 0 ;
18426 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18427 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18428 void *argp1 = 0 ;
18429 int res1 = 0 ;
18430 bool temp2 = false ;
18431 void *argp3 = 0 ;
18432 int res3 = 0 ;
18433 void *argp4 = 0 ;
18434 int res4 = 0 ;
18435 PyObject * obj0 = 0 ;
18436 PyObject * obj1 = 0 ;
18437 PyObject * obj2 = 0 ;
18438 PyObject * obj3 = 0 ;
18439 char * kwnames[] = {
18440 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18441 };
18442
18443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18445 if (!SWIG_IsOK(res1)) {
18446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18447 }
18448 arg1 = reinterpret_cast< wxGrid * >(argp1);
18449 {
18450 arg2 = wxString_in_helper(obj1);
18451 if (arg2 == NULL) SWIG_fail;
18452 temp2 = true;
18453 }
18454 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18455 if (!SWIG_IsOK(res3)) {
18456 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18457 }
18458 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18459 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18460 if (!SWIG_IsOK(res4)) {
18461 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18462 }
18463 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 resultobj = SWIG_Py_Void();
18471 {
18472 if (temp2)
18473 delete arg2;
18474 }
18475 return resultobj;
18476 fail:
18477 {
18478 if (temp2)
18479 delete arg2;
18480 }
18481 return NULL;
18482 }
18483
18484
18485 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18486 PyObject *resultobj = 0;
18487 wxGrid *arg1 = (wxGrid *) 0 ;
18488 int arg2 ;
18489 int arg3 ;
18490 wxGridCellEditor *result = 0 ;
18491 void *argp1 = 0 ;
18492 int res1 = 0 ;
18493 int val2 ;
18494 int ecode2 = 0 ;
18495 int val3 ;
18496 int ecode3 = 0 ;
18497 PyObject * obj0 = 0 ;
18498 PyObject * obj1 = 0 ;
18499 PyObject * obj2 = 0 ;
18500 char * kwnames[] = {
18501 (char *) "self",(char *) "row",(char *) "col", NULL
18502 };
18503
18504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18506 if (!SWIG_IsOK(res1)) {
18507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18508 }
18509 arg1 = reinterpret_cast< wxGrid * >(argp1);
18510 ecode2 = SWIG_AsVal_int(obj1, &val2);
18511 if (!SWIG_IsOK(ecode2)) {
18512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18513 }
18514 arg2 = static_cast< int >(val2);
18515 ecode3 = SWIG_AsVal_int(obj2, &val3);
18516 if (!SWIG_IsOK(ecode3)) {
18517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18518 }
18519 arg3 = static_cast< int >(val3);
18520 {
18521 PyThreadState* __tstate = wxPyBeginAllowThreads();
18522 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18523 wxPyEndAllowThreads(__tstate);
18524 if (PyErr_Occurred()) SWIG_fail;
18525 }
18526 {
18527 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18528 }
18529 return resultobj;
18530 fail:
18531 return NULL;
18532 }
18533
18534
18535 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18536 PyObject *resultobj = 0;
18537 wxGrid *arg1 = (wxGrid *) 0 ;
18538 int arg2 ;
18539 int arg3 ;
18540 wxGridCellRenderer *result = 0 ;
18541 void *argp1 = 0 ;
18542 int res1 = 0 ;
18543 int val2 ;
18544 int ecode2 = 0 ;
18545 int val3 ;
18546 int ecode3 = 0 ;
18547 PyObject * obj0 = 0 ;
18548 PyObject * obj1 = 0 ;
18549 PyObject * obj2 = 0 ;
18550 char * kwnames[] = {
18551 (char *) "self",(char *) "row",(char *) "col", NULL
18552 };
18553
18554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18556 if (!SWIG_IsOK(res1)) {
18557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18558 }
18559 arg1 = reinterpret_cast< wxGrid * >(argp1);
18560 ecode2 = SWIG_AsVal_int(obj1, &val2);
18561 if (!SWIG_IsOK(ecode2)) {
18562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18563 }
18564 arg2 = static_cast< int >(val2);
18565 ecode3 = SWIG_AsVal_int(obj2, &val3);
18566 if (!SWIG_IsOK(ecode3)) {
18567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18568 }
18569 arg3 = static_cast< int >(val3);
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18573 wxPyEndAllowThreads(__tstate);
18574 if (PyErr_Occurred()) SWIG_fail;
18575 }
18576 {
18577 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18578 }
18579 return resultobj;
18580 fail:
18581 return NULL;
18582 }
18583
18584
18585 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18586 PyObject *resultobj = 0;
18587 wxGrid *arg1 = (wxGrid *) 0 ;
18588 wxString *arg2 = 0 ;
18589 wxGridCellEditor *result = 0 ;
18590 void *argp1 = 0 ;
18591 int res1 = 0 ;
18592 bool temp2 = false ;
18593 PyObject * obj0 = 0 ;
18594 PyObject * obj1 = 0 ;
18595 char * kwnames[] = {
18596 (char *) "self",(char *) "typeName", NULL
18597 };
18598
18599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18601 if (!SWIG_IsOK(res1)) {
18602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18603 }
18604 arg1 = reinterpret_cast< wxGrid * >(argp1);
18605 {
18606 arg2 = wxString_in_helper(obj1);
18607 if (arg2 == NULL) SWIG_fail;
18608 temp2 = true;
18609 }
18610 {
18611 PyThreadState* __tstate = wxPyBeginAllowThreads();
18612 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 {
18617 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18618 }
18619 {
18620 if (temp2)
18621 delete arg2;
18622 }
18623 return resultobj;
18624 fail:
18625 {
18626 if (temp2)
18627 delete arg2;
18628 }
18629 return NULL;
18630 }
18631
18632
18633 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18634 PyObject *resultobj = 0;
18635 wxGrid *arg1 = (wxGrid *) 0 ;
18636 wxString *arg2 = 0 ;
18637 wxGridCellRenderer *result = 0 ;
18638 void *argp1 = 0 ;
18639 int res1 = 0 ;
18640 bool temp2 = false ;
18641 PyObject * obj0 = 0 ;
18642 PyObject * obj1 = 0 ;
18643 char * kwnames[] = {
18644 (char *) "self",(char *) "typeName", NULL
18645 };
18646
18647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18649 if (!SWIG_IsOK(res1)) {
18650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18651 }
18652 arg1 = reinterpret_cast< wxGrid * >(argp1);
18653 {
18654 arg2 = wxString_in_helper(obj1);
18655 if (arg2 == NULL) SWIG_fail;
18656 temp2 = true;
18657 }
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 {
18665 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18666 }
18667 {
18668 if (temp2)
18669 delete arg2;
18670 }
18671 return resultobj;
18672 fail:
18673 {
18674 if (temp2)
18675 delete arg2;
18676 }
18677 return NULL;
18678 }
18679
18680
18681 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj = 0;
18683 wxGrid *arg1 = (wxGrid *) 0 ;
18684 int arg2 ;
18685 int arg3 ;
18686 void *argp1 = 0 ;
18687 int res1 = 0 ;
18688 int val2 ;
18689 int ecode2 = 0 ;
18690 int val3 ;
18691 int ecode3 = 0 ;
18692 PyObject * obj0 = 0 ;
18693 PyObject * obj1 = 0 ;
18694 PyObject * obj2 = 0 ;
18695 char * kwnames[] = {
18696 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18697 };
18698
18699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18701 if (!SWIG_IsOK(res1)) {
18702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18703 }
18704 arg1 = reinterpret_cast< wxGrid * >(argp1);
18705 ecode2 = SWIG_AsVal_int(obj1, &val2);
18706 if (!SWIG_IsOK(ecode2)) {
18707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18708 }
18709 arg2 = static_cast< int >(val2);
18710 ecode3 = SWIG_AsVal_int(obj2, &val3);
18711 if (!SWIG_IsOK(ecode3)) {
18712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18713 }
18714 arg3 = static_cast< int >(val3);
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 (arg1)->SetMargins(arg2,arg3);
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 resultobj = SWIG_Py_Void();
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18729 PyObject *resultobj = 0;
18730 wxGrid *arg1 = (wxGrid *) 0 ;
18731 wxWindow *result = 0 ;
18732 void *argp1 = 0 ;
18733 int res1 = 0 ;
18734 PyObject *swig_obj[1] ;
18735
18736 if (!args) SWIG_fail;
18737 swig_obj[0] = args;
18738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18739 if (!SWIG_IsOK(res1)) {
18740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18741 }
18742 arg1 = reinterpret_cast< wxGrid * >(argp1);
18743 {
18744 PyThreadState* __tstate = wxPyBeginAllowThreads();
18745 result = (wxWindow *)(arg1)->GetGridWindow();
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 {
18750 resultobj = wxPyMake_wxObject(result, 0);
18751 }
18752 return resultobj;
18753 fail:
18754 return NULL;
18755 }
18756
18757
18758 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18759 PyObject *resultobj = 0;
18760 wxGrid *arg1 = (wxGrid *) 0 ;
18761 wxWindow *result = 0 ;
18762 void *argp1 = 0 ;
18763 int res1 = 0 ;
18764 PyObject *swig_obj[1] ;
18765
18766 if (!args) SWIG_fail;
18767 swig_obj[0] = args;
18768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18769 if (!SWIG_IsOK(res1)) {
18770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18771 }
18772 arg1 = reinterpret_cast< wxGrid * >(argp1);
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 {
18780 resultobj = wxPyMake_wxObject(result, 0);
18781 }
18782 return resultobj;
18783 fail:
18784 return NULL;
18785 }
18786
18787
18788 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18789 PyObject *resultobj = 0;
18790 wxGrid *arg1 = (wxGrid *) 0 ;
18791 wxWindow *result = 0 ;
18792 void *argp1 = 0 ;
18793 int res1 = 0 ;
18794 PyObject *swig_obj[1] ;
18795
18796 if (!args) SWIG_fail;
18797 swig_obj[0] = args;
18798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18799 if (!SWIG_IsOK(res1)) {
18800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18801 }
18802 arg1 = reinterpret_cast< wxGrid * >(argp1);
18803 {
18804 PyThreadState* __tstate = wxPyBeginAllowThreads();
18805 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18806 wxPyEndAllowThreads(__tstate);
18807 if (PyErr_Occurred()) SWIG_fail;
18808 }
18809 {
18810 resultobj = wxPyMake_wxObject(result, 0);
18811 }
18812 return resultobj;
18813 fail:
18814 return NULL;
18815 }
18816
18817
18818 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18819 PyObject *resultobj = 0;
18820 wxGrid *arg1 = (wxGrid *) 0 ;
18821 wxWindow *result = 0 ;
18822 void *argp1 = 0 ;
18823 int res1 = 0 ;
18824 PyObject *swig_obj[1] ;
18825
18826 if (!args) SWIG_fail;
18827 swig_obj[0] = args;
18828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18829 if (!SWIG_IsOK(res1)) {
18830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18831 }
18832 arg1 = reinterpret_cast< wxGrid * >(argp1);
18833 {
18834 PyThreadState* __tstate = wxPyBeginAllowThreads();
18835 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18836 wxPyEndAllowThreads(__tstate);
18837 if (PyErr_Occurred()) SWIG_fail;
18838 }
18839 {
18840 resultobj = wxPyMake_wxObject(result, 0);
18841 }
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18849 PyObject *resultobj = 0;
18850 wxGrid *arg1 = (wxGrid *) 0 ;
18851 int arg2 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 int val2 ;
18855 int ecode2 = 0 ;
18856 PyObject * obj0 = 0 ;
18857 PyObject * obj1 = 0 ;
18858 char * kwnames[] = {
18859 (char *) "self",(char *) "x", NULL
18860 };
18861
18862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18864 if (!SWIG_IsOK(res1)) {
18865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18866 }
18867 arg1 = reinterpret_cast< wxGrid * >(argp1);
18868 ecode2 = SWIG_AsVal_int(obj1, &val2);
18869 if (!SWIG_IsOK(ecode2)) {
18870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18871 }
18872 arg2 = static_cast< int >(val2);
18873 {
18874 PyThreadState* __tstate = wxPyBeginAllowThreads();
18875 (arg1)->SetScrollLineX(arg2);
18876 wxPyEndAllowThreads(__tstate);
18877 if (PyErr_Occurred()) SWIG_fail;
18878 }
18879 resultobj = SWIG_Py_Void();
18880 return resultobj;
18881 fail:
18882 return NULL;
18883 }
18884
18885
18886 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18887 PyObject *resultobj = 0;
18888 wxGrid *arg1 = (wxGrid *) 0 ;
18889 int arg2 ;
18890 void *argp1 = 0 ;
18891 int res1 = 0 ;
18892 int val2 ;
18893 int ecode2 = 0 ;
18894 PyObject * obj0 = 0 ;
18895 PyObject * obj1 = 0 ;
18896 char * kwnames[] = {
18897 (char *) "self",(char *) "y", NULL
18898 };
18899
18900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18902 if (!SWIG_IsOK(res1)) {
18903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18904 }
18905 arg1 = reinterpret_cast< wxGrid * >(argp1);
18906 ecode2 = SWIG_AsVal_int(obj1, &val2);
18907 if (!SWIG_IsOK(ecode2)) {
18908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18909 }
18910 arg2 = static_cast< int >(val2);
18911 {
18912 PyThreadState* __tstate = wxPyBeginAllowThreads();
18913 (arg1)->SetScrollLineY(arg2);
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 resultobj = SWIG_Py_Void();
18918 return resultobj;
18919 fail:
18920 return NULL;
18921 }
18922
18923
18924 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18925 PyObject *resultobj = 0;
18926 wxGrid *arg1 = (wxGrid *) 0 ;
18927 int result;
18928 void *argp1 = 0 ;
18929 int res1 = 0 ;
18930 PyObject *swig_obj[1] ;
18931
18932 if (!args) SWIG_fail;
18933 swig_obj[0] = args;
18934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18935 if (!SWIG_IsOK(res1)) {
18936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18937 }
18938 arg1 = reinterpret_cast< wxGrid * >(argp1);
18939 {
18940 PyThreadState* __tstate = wxPyBeginAllowThreads();
18941 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18942 wxPyEndAllowThreads(__tstate);
18943 if (PyErr_Occurred()) SWIG_fail;
18944 }
18945 resultobj = SWIG_From_int(static_cast< int >(result));
18946 return resultobj;
18947 fail:
18948 return NULL;
18949 }
18950
18951
18952 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18953 PyObject *resultobj = 0;
18954 wxGrid *arg1 = (wxGrid *) 0 ;
18955 int result;
18956 void *argp1 = 0 ;
18957 int res1 = 0 ;
18958 PyObject *swig_obj[1] ;
18959
18960 if (!args) SWIG_fail;
18961 swig_obj[0] = args;
18962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18963 if (!SWIG_IsOK(res1)) {
18964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18965 }
18966 arg1 = reinterpret_cast< wxGrid * >(argp1);
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 resultobj = SWIG_From_int(static_cast< int >(result));
18974 return resultobj;
18975 fail:
18976 return NULL;
18977 }
18978
18979
18980 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18981 PyObject *resultobj = 0;
18982 wxGrid *arg1 = (wxGrid *) 0 ;
18983 int arg2 ;
18984 int result;
18985 void *argp1 = 0 ;
18986 int res1 = 0 ;
18987 int val2 ;
18988 int ecode2 = 0 ;
18989 PyObject * obj0 = 0 ;
18990 PyObject * obj1 = 0 ;
18991 char * kwnames[] = {
18992 (char *) "self",(char *) "x", NULL
18993 };
18994
18995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18997 if (!SWIG_IsOK(res1)) {
18998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18999 }
19000 arg1 = reinterpret_cast< wxGrid * >(argp1);
19001 ecode2 = SWIG_AsVal_int(obj1, &val2);
19002 if (!SWIG_IsOK(ecode2)) {
19003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
19004 }
19005 arg2 = static_cast< int >(val2);
19006 {
19007 PyThreadState* __tstate = wxPyBeginAllowThreads();
19008 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
19009 wxPyEndAllowThreads(__tstate);
19010 if (PyErr_Occurred()) SWIG_fail;
19011 }
19012 resultobj = SWIG_From_int(static_cast< int >(result));
19013 return resultobj;
19014 fail:
19015 return NULL;
19016 }
19017
19018
19019 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19020 PyObject *resultobj = 0;
19021 wxGrid *arg1 = (wxGrid *) 0 ;
19022 int arg2 ;
19023 int result;
19024 void *argp1 = 0 ;
19025 int res1 = 0 ;
19026 int val2 ;
19027 int ecode2 = 0 ;
19028 PyObject * obj0 = 0 ;
19029 PyObject * obj1 = 0 ;
19030 char * kwnames[] = {
19031 (char *) "self",(char *) "y", NULL
19032 };
19033
19034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
19035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19036 if (!SWIG_IsOK(res1)) {
19037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
19038 }
19039 arg1 = reinterpret_cast< wxGrid * >(argp1);
19040 ecode2 = SWIG_AsVal_int(obj1, &val2);
19041 if (!SWIG_IsOK(ecode2)) {
19042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
19043 }
19044 arg2 = static_cast< int >(val2);
19045 {
19046 PyThreadState* __tstate = wxPyBeginAllowThreads();
19047 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
19048 wxPyEndAllowThreads(__tstate);
19049 if (PyErr_Occurred()) SWIG_fail;
19050 }
19051 resultobj = SWIG_From_int(static_cast< int >(result));
19052 return resultobj;
19053 fail:
19054 return NULL;
19055 }
19056
19057
19058 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19059 PyObject *resultobj = 0;
19060 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
19061 SwigValueWrapper<wxVisualAttributes > result;
19062 int val1 ;
19063 int ecode1 = 0 ;
19064 PyObject * obj0 = 0 ;
19065 char * kwnames[] = {
19066 (char *) "variant", NULL
19067 };
19068
19069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
19070 if (obj0) {
19071 ecode1 = SWIG_AsVal_int(obj0, &val1);
19072 if (!SWIG_IsOK(ecode1)) {
19073 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
19074 }
19075 arg1 = static_cast< wxWindowVariant >(val1);
19076 }
19077 {
19078 if (!wxPyCheckForApp()) SWIG_fail;
19079 PyThreadState* __tstate = wxPyBeginAllowThreads();
19080 result = wxGrid::GetClassDefaultAttributes(arg1);
19081 wxPyEndAllowThreads(__tstate);
19082 if (PyErr_Occurred()) SWIG_fail;
19083 }
19084 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19092 PyObject *obj;
19093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19094 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
19095 return SWIG_Py_Void();
19096 }
19097
19098 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19099 return SWIG_Python_InitShadowInstance(args);
19100 }
19101
19102 SWIGINTERN PyObject *_wrap_new_GridUpdateLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19103 PyObject *resultobj = 0;
19104 wxGrid *arg1 = (wxGrid *) NULL ;
19105 wxGridUpdateLocker *result = 0 ;
19106 void *argp1 = 0 ;
19107 int res1 = 0 ;
19108 PyObject * obj0 = 0 ;
19109 char * kwnames[] = {
19110 (char *) "grid", NULL
19111 };
19112
19113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridUpdateLocker",kwnames,&obj0)) SWIG_fail;
19114 if (obj0) {
19115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19116 if (!SWIG_IsOK(res1)) {
19117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridUpdateLocker" "', expected argument " "1"" of type '" "wxGrid *""'");
19118 }
19119 arg1 = reinterpret_cast< wxGrid * >(argp1);
19120 }
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 result = (wxGridUpdateLocker *)new wxGridUpdateLocker(arg1);
19124 wxPyEndAllowThreads(__tstate);
19125 if (PyErr_Occurred()) SWIG_fail;
19126 }
19127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridUpdateLocker, SWIG_POINTER_NEW | 0 );
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 SWIGINTERN PyObject *_wrap_delete_GridUpdateLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19135 PyObject *resultobj = 0;
19136 wxGridUpdateLocker *arg1 = (wxGridUpdateLocker *) 0 ;
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_wxGridUpdateLocker, SWIG_POINTER_DISOWN | 0 );
19144 if (!SWIG_IsOK(res1)) {
19145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridUpdateLocker" "', expected argument " "1"" of type '" "wxGridUpdateLocker *""'");
19146 }
19147 arg1 = reinterpret_cast< wxGridUpdateLocker * >(argp1);
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 delete arg1;
19151
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_Py_Void();
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_GridUpdateLocker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj = 0;
19164 wxGridUpdateLocker *arg1 = (wxGridUpdateLocker *) 0 ;
19165 wxGrid *arg2 = (wxGrid *) 0 ;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 void *argp2 = 0 ;
19169 int res2 = 0 ;
19170 PyObject * obj0 = 0 ;
19171 PyObject * obj1 = 0 ;
19172 char * kwnames[] = {
19173 (char *) "self",(char *) "grid", NULL
19174 };
19175
19176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridUpdateLocker_Create",kwnames,&obj0,&obj1)) SWIG_fail;
19177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridUpdateLocker, 0 | 0 );
19178 if (!SWIG_IsOK(res1)) {
19179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridUpdateLocker_Create" "', expected argument " "1"" of type '" "wxGridUpdateLocker *""'");
19180 }
19181 arg1 = reinterpret_cast< wxGridUpdateLocker * >(argp1);
19182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
19183 if (!SWIG_IsOK(res2)) {
19184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridUpdateLocker_Create" "', expected argument " "2"" of type '" "wxGrid *""'");
19185 }
19186 arg2 = reinterpret_cast< wxGrid * >(argp2);
19187 {
19188 PyThreadState* __tstate = wxPyBeginAllowThreads();
19189 (arg1)->Create(arg2);
19190 wxPyEndAllowThreads(__tstate);
19191 if (PyErr_Occurred()) SWIG_fail;
19192 }
19193 resultobj = SWIG_Py_Void();
19194 return resultobj;
19195 fail:
19196 return NULL;
19197 }
19198
19199
19200 SWIGINTERN PyObject *GridUpdateLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19201 PyObject *obj;
19202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19203 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridUpdateLocker, SWIG_NewClientData(obj));
19204 return SWIG_Py_Void();
19205 }
19206
19207 SWIGINTERN PyObject *GridUpdateLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19208 return SWIG_Python_InitShadowInstance(args);
19209 }
19210
19211 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj = 0;
19213 int arg1 ;
19214 wxEventType arg2 ;
19215 wxGrid *arg3 = (wxGrid *) 0 ;
19216 int arg4 = (int) -1 ;
19217 int arg5 = (int) -1 ;
19218 int arg6 = (int) -1 ;
19219 int arg7 = (int) -1 ;
19220 bool arg8 = (bool) true ;
19221 bool arg9 = (bool) false ;
19222 bool arg10 = (bool) false ;
19223 bool arg11 = (bool) false ;
19224 bool arg12 = (bool) false ;
19225 wxGridEvent *result = 0 ;
19226 int val1 ;
19227 int ecode1 = 0 ;
19228 int val2 ;
19229 int ecode2 = 0 ;
19230 void *argp3 = 0 ;
19231 int res3 = 0 ;
19232 int val4 ;
19233 int ecode4 = 0 ;
19234 int val5 ;
19235 int ecode5 = 0 ;
19236 int val6 ;
19237 int ecode6 = 0 ;
19238 int val7 ;
19239 int ecode7 = 0 ;
19240 bool val8 ;
19241 int ecode8 = 0 ;
19242 bool val9 ;
19243 int ecode9 = 0 ;
19244 bool val10 ;
19245 int ecode10 = 0 ;
19246 bool val11 ;
19247 int ecode11 = 0 ;
19248 bool val12 ;
19249 int ecode12 = 0 ;
19250 PyObject * obj0 = 0 ;
19251 PyObject * obj1 = 0 ;
19252 PyObject * obj2 = 0 ;
19253 PyObject * obj3 = 0 ;
19254 PyObject * obj4 = 0 ;
19255 PyObject * obj5 = 0 ;
19256 PyObject * obj6 = 0 ;
19257 PyObject * obj7 = 0 ;
19258 PyObject * obj8 = 0 ;
19259 PyObject * obj9 = 0 ;
19260 PyObject * obj10 = 0 ;
19261 PyObject * obj11 = 0 ;
19262 char * kwnames[] = {
19263 (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
19264 };
19265
19266 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;
19267 ecode1 = SWIG_AsVal_int(obj0, &val1);
19268 if (!SWIG_IsOK(ecode1)) {
19269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
19270 }
19271 arg1 = static_cast< int >(val1);
19272 ecode2 = SWIG_AsVal_int(obj1, &val2);
19273 if (!SWIG_IsOK(ecode2)) {
19274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19275 }
19276 arg2 = static_cast< wxEventType >(val2);
19277 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19278 if (!SWIG_IsOK(res3)) {
19279 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19280 }
19281 arg3 = reinterpret_cast< wxGrid * >(argp3);
19282 if (obj3) {
19283 ecode4 = SWIG_AsVal_int(obj3, &val4);
19284 if (!SWIG_IsOK(ecode4)) {
19285 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
19286 }
19287 arg4 = static_cast< int >(val4);
19288 }
19289 if (obj4) {
19290 ecode5 = SWIG_AsVal_int(obj4, &val5);
19291 if (!SWIG_IsOK(ecode5)) {
19292 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
19293 }
19294 arg5 = static_cast< int >(val5);
19295 }
19296 if (obj5) {
19297 ecode6 = SWIG_AsVal_int(obj5, &val6);
19298 if (!SWIG_IsOK(ecode6)) {
19299 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
19300 }
19301 arg6 = static_cast< int >(val6);
19302 }
19303 if (obj6) {
19304 ecode7 = SWIG_AsVal_int(obj6, &val7);
19305 if (!SWIG_IsOK(ecode7)) {
19306 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
19307 }
19308 arg7 = static_cast< int >(val7);
19309 }
19310 if (obj7) {
19311 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19312 if (!SWIG_IsOK(ecode8)) {
19313 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
19314 }
19315 arg8 = static_cast< bool >(val8);
19316 }
19317 if (obj8) {
19318 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19319 if (!SWIG_IsOK(ecode9)) {
19320 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
19321 }
19322 arg9 = static_cast< bool >(val9);
19323 }
19324 if (obj9) {
19325 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19326 if (!SWIG_IsOK(ecode10)) {
19327 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
19328 }
19329 arg10 = static_cast< bool >(val10);
19330 }
19331 if (obj10) {
19332 ecode11 = SWIG_AsVal_bool(obj10, &val11);
19333 if (!SWIG_IsOK(ecode11)) {
19334 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
19335 }
19336 arg11 = static_cast< bool >(val11);
19337 }
19338 if (obj11) {
19339 ecode12 = SWIG_AsVal_bool(obj11, &val12);
19340 if (!SWIG_IsOK(ecode12)) {
19341 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
19342 }
19343 arg12 = static_cast< bool >(val12);
19344 }
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19359 PyObject *resultobj = 0;
19360 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19361 int result;
19362 void *argp1 = 0 ;
19363 int res1 = 0 ;
19364 PyObject *swig_obj[1] ;
19365
19366 if (!args) SWIG_fail;
19367 swig_obj[0] = args;
19368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19369 if (!SWIG_IsOK(res1)) {
19370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19371 }
19372 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = (int)(arg1)->GetRow();
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 resultobj = SWIG_From_int(static_cast< int >(result));
19380 return resultobj;
19381 fail:
19382 return NULL;
19383 }
19384
19385
19386 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19387 PyObject *resultobj = 0;
19388 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19389 int result;
19390 void *argp1 = 0 ;
19391 int res1 = 0 ;
19392 PyObject *swig_obj[1] ;
19393
19394 if (!args) SWIG_fail;
19395 swig_obj[0] = args;
19396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19397 if (!SWIG_IsOK(res1)) {
19398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19399 }
19400 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19401 {
19402 PyThreadState* __tstate = wxPyBeginAllowThreads();
19403 result = (int)(arg1)->GetCol();
19404 wxPyEndAllowThreads(__tstate);
19405 if (PyErr_Occurred()) SWIG_fail;
19406 }
19407 resultobj = SWIG_From_int(static_cast< int >(result));
19408 return resultobj;
19409 fail:
19410 return NULL;
19411 }
19412
19413
19414 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19415 PyObject *resultobj = 0;
19416 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19417 wxPoint result;
19418 void *argp1 = 0 ;
19419 int res1 = 0 ;
19420 PyObject *swig_obj[1] ;
19421
19422 if (!args) SWIG_fail;
19423 swig_obj[0] = args;
19424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19425 if (!SWIG_IsOK(res1)) {
19426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19427 }
19428 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19429 {
19430 PyThreadState* __tstate = wxPyBeginAllowThreads();
19431 result = (arg1)->GetPosition();
19432 wxPyEndAllowThreads(__tstate);
19433 if (PyErr_Occurred()) SWIG_fail;
19434 }
19435 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19436 return resultobj;
19437 fail:
19438 return NULL;
19439 }
19440
19441
19442 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19443 PyObject *resultobj = 0;
19444 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19445 bool result;
19446 void *argp1 = 0 ;
19447 int res1 = 0 ;
19448 PyObject *swig_obj[1] ;
19449
19450 if (!args) SWIG_fail;
19451 swig_obj[0] = args;
19452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19453 if (!SWIG_IsOK(res1)) {
19454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19455 }
19456 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19457 {
19458 PyThreadState* __tstate = wxPyBeginAllowThreads();
19459 result = (bool)(arg1)->Selecting();
19460 wxPyEndAllowThreads(__tstate);
19461 if (PyErr_Occurred()) SWIG_fail;
19462 }
19463 {
19464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19465 }
19466 return resultobj;
19467 fail:
19468 return NULL;
19469 }
19470
19471
19472 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19473 PyObject *resultobj = 0;
19474 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19475 bool result;
19476 void *argp1 = 0 ;
19477 int res1 = 0 ;
19478 PyObject *swig_obj[1] ;
19479
19480 if (!args) SWIG_fail;
19481 swig_obj[0] = args;
19482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19483 if (!SWIG_IsOK(res1)) {
19484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19485 }
19486 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19487 {
19488 PyThreadState* __tstate = wxPyBeginAllowThreads();
19489 result = (bool)(arg1)->ControlDown();
19490 wxPyEndAllowThreads(__tstate);
19491 if (PyErr_Occurred()) SWIG_fail;
19492 }
19493 {
19494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19495 }
19496 return resultobj;
19497 fail:
19498 return NULL;
19499 }
19500
19501
19502 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19503 PyObject *resultobj = 0;
19504 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19505 bool result;
19506 void *argp1 = 0 ;
19507 int res1 = 0 ;
19508 PyObject *swig_obj[1] ;
19509
19510 if (!args) SWIG_fail;
19511 swig_obj[0] = args;
19512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19513 if (!SWIG_IsOK(res1)) {
19514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19515 }
19516 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19517 {
19518 PyThreadState* __tstate = wxPyBeginAllowThreads();
19519 result = (bool)(arg1)->MetaDown();
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 {
19524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19525 }
19526 return resultobj;
19527 fail:
19528 return NULL;
19529 }
19530
19531
19532 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19533 PyObject *resultobj = 0;
19534 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19535 bool result;
19536 void *argp1 = 0 ;
19537 int res1 = 0 ;
19538 PyObject *swig_obj[1] ;
19539
19540 if (!args) SWIG_fail;
19541 swig_obj[0] = args;
19542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19543 if (!SWIG_IsOK(res1)) {
19544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19545 }
19546 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (bool)(arg1)->ShiftDown();
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 {
19554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19555 }
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19563 PyObject *resultobj = 0;
19564 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19565 bool result;
19566 void *argp1 = 0 ;
19567 int res1 = 0 ;
19568 PyObject *swig_obj[1] ;
19569
19570 if (!args) SWIG_fail;
19571 swig_obj[0] = args;
19572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19573 if (!SWIG_IsOK(res1)) {
19574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19575 }
19576 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19577 {
19578 PyThreadState* __tstate = wxPyBeginAllowThreads();
19579 result = (bool)(arg1)->AltDown();
19580 wxPyEndAllowThreads(__tstate);
19581 if (PyErr_Occurred()) SWIG_fail;
19582 }
19583 {
19584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19585 }
19586 return resultobj;
19587 fail:
19588 return NULL;
19589 }
19590
19591
19592 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19593 PyObject *resultobj = 0;
19594 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19595 bool result;
19596 void *argp1 = 0 ;
19597 int res1 = 0 ;
19598 PyObject *swig_obj[1] ;
19599
19600 if (!args) SWIG_fail;
19601 swig_obj[0] = args;
19602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19603 if (!SWIG_IsOK(res1)) {
19604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19605 }
19606 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19607 {
19608 PyThreadState* __tstate = wxPyBeginAllowThreads();
19609 result = (bool)(arg1)->CmdDown();
19610 wxPyEndAllowThreads(__tstate);
19611 if (PyErr_Occurred()) SWIG_fail;
19612 }
19613 {
19614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19615 }
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19623 PyObject *obj;
19624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19625 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19626 return SWIG_Py_Void();
19627 }
19628
19629 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19630 return SWIG_Python_InitShadowInstance(args);
19631 }
19632
19633 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19634 PyObject *resultobj = 0;
19635 int arg1 ;
19636 wxEventType arg2 ;
19637 wxGrid *arg3 = (wxGrid *) 0 ;
19638 int arg4 = (int) -1 ;
19639 int arg5 = (int) -1 ;
19640 int arg6 = (int) -1 ;
19641 bool arg7 = (bool) false ;
19642 bool arg8 = (bool) false ;
19643 bool arg9 = (bool) false ;
19644 bool arg10 = (bool) false ;
19645 wxGridSizeEvent *result = 0 ;
19646 int val1 ;
19647 int ecode1 = 0 ;
19648 int val2 ;
19649 int ecode2 = 0 ;
19650 void *argp3 = 0 ;
19651 int res3 = 0 ;
19652 int val4 ;
19653 int ecode4 = 0 ;
19654 int val5 ;
19655 int ecode5 = 0 ;
19656 int val6 ;
19657 int ecode6 = 0 ;
19658 bool val7 ;
19659 int ecode7 = 0 ;
19660 bool val8 ;
19661 int ecode8 = 0 ;
19662 bool val9 ;
19663 int ecode9 = 0 ;
19664 bool val10 ;
19665 int ecode10 = 0 ;
19666 PyObject * obj0 = 0 ;
19667 PyObject * obj1 = 0 ;
19668 PyObject * obj2 = 0 ;
19669 PyObject * obj3 = 0 ;
19670 PyObject * obj4 = 0 ;
19671 PyObject * obj5 = 0 ;
19672 PyObject * obj6 = 0 ;
19673 PyObject * obj7 = 0 ;
19674 PyObject * obj8 = 0 ;
19675 PyObject * obj9 = 0 ;
19676 char * kwnames[] = {
19677 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19678 };
19679
19680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19681 ecode1 = SWIG_AsVal_int(obj0, &val1);
19682 if (!SWIG_IsOK(ecode1)) {
19683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19684 }
19685 arg1 = static_cast< int >(val1);
19686 ecode2 = SWIG_AsVal_int(obj1, &val2);
19687 if (!SWIG_IsOK(ecode2)) {
19688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19689 }
19690 arg2 = static_cast< wxEventType >(val2);
19691 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19692 if (!SWIG_IsOK(res3)) {
19693 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19694 }
19695 arg3 = reinterpret_cast< wxGrid * >(argp3);
19696 if (obj3) {
19697 ecode4 = SWIG_AsVal_int(obj3, &val4);
19698 if (!SWIG_IsOK(ecode4)) {
19699 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19700 }
19701 arg4 = static_cast< int >(val4);
19702 }
19703 if (obj4) {
19704 ecode5 = SWIG_AsVal_int(obj4, &val5);
19705 if (!SWIG_IsOK(ecode5)) {
19706 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19707 }
19708 arg5 = static_cast< int >(val5);
19709 }
19710 if (obj5) {
19711 ecode6 = SWIG_AsVal_int(obj5, &val6);
19712 if (!SWIG_IsOK(ecode6)) {
19713 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19714 }
19715 arg6 = static_cast< int >(val6);
19716 }
19717 if (obj6) {
19718 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19719 if (!SWIG_IsOK(ecode7)) {
19720 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19721 }
19722 arg7 = static_cast< bool >(val7);
19723 }
19724 if (obj7) {
19725 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19726 if (!SWIG_IsOK(ecode8)) {
19727 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19728 }
19729 arg8 = static_cast< bool >(val8);
19730 }
19731 if (obj8) {
19732 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19733 if (!SWIG_IsOK(ecode9)) {
19734 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19735 }
19736 arg9 = static_cast< bool >(val9);
19737 }
19738 if (obj9) {
19739 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19740 if (!SWIG_IsOK(ecode10)) {
19741 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19742 }
19743 arg10 = static_cast< bool >(val10);
19744 }
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19748 wxPyEndAllowThreads(__tstate);
19749 if (PyErr_Occurred()) SWIG_fail;
19750 }
19751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19752 return resultobj;
19753 fail:
19754 return NULL;
19755 }
19756
19757
19758 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19759 PyObject *resultobj = 0;
19760 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19761 int result;
19762 void *argp1 = 0 ;
19763 int res1 = 0 ;
19764 PyObject *swig_obj[1] ;
19765
19766 if (!args) SWIG_fail;
19767 swig_obj[0] = args;
19768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19769 if (!SWIG_IsOK(res1)) {
19770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19771 }
19772 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19773 {
19774 PyThreadState* __tstate = wxPyBeginAllowThreads();
19775 result = (int)(arg1)->GetRowOrCol();
19776 wxPyEndAllowThreads(__tstate);
19777 if (PyErr_Occurred()) SWIG_fail;
19778 }
19779 resultobj = SWIG_From_int(static_cast< int >(result));
19780 return resultobj;
19781 fail:
19782 return NULL;
19783 }
19784
19785
19786 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19787 PyObject *resultobj = 0;
19788 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19789 wxPoint result;
19790 void *argp1 = 0 ;
19791 int res1 = 0 ;
19792 PyObject *swig_obj[1] ;
19793
19794 if (!args) SWIG_fail;
19795 swig_obj[0] = args;
19796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19797 if (!SWIG_IsOK(res1)) {
19798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19799 }
19800 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19801 {
19802 PyThreadState* __tstate = wxPyBeginAllowThreads();
19803 result = (arg1)->GetPosition();
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19815 PyObject *resultobj = 0;
19816 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19817 bool result;
19818 void *argp1 = 0 ;
19819 int res1 = 0 ;
19820 PyObject *swig_obj[1] ;
19821
19822 if (!args) SWIG_fail;
19823 swig_obj[0] = args;
19824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19825 if (!SWIG_IsOK(res1)) {
19826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19827 }
19828 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19829 {
19830 PyThreadState* __tstate = wxPyBeginAllowThreads();
19831 result = (bool)(arg1)->ControlDown();
19832 wxPyEndAllowThreads(__tstate);
19833 if (PyErr_Occurred()) SWIG_fail;
19834 }
19835 {
19836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19837 }
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19845 PyObject *resultobj = 0;
19846 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19847 bool result;
19848 void *argp1 = 0 ;
19849 int res1 = 0 ;
19850 PyObject *swig_obj[1] ;
19851
19852 if (!args) SWIG_fail;
19853 swig_obj[0] = args;
19854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19855 if (!SWIG_IsOK(res1)) {
19856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19857 }
19858 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19859 {
19860 PyThreadState* __tstate = wxPyBeginAllowThreads();
19861 result = (bool)(arg1)->MetaDown();
19862 wxPyEndAllowThreads(__tstate);
19863 if (PyErr_Occurred()) SWIG_fail;
19864 }
19865 {
19866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19867 }
19868 return resultobj;
19869 fail:
19870 return NULL;
19871 }
19872
19873
19874 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19875 PyObject *resultobj = 0;
19876 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19877 bool result;
19878 void *argp1 = 0 ;
19879 int res1 = 0 ;
19880 PyObject *swig_obj[1] ;
19881
19882 if (!args) SWIG_fail;
19883 swig_obj[0] = args;
19884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19885 if (!SWIG_IsOK(res1)) {
19886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19887 }
19888 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19889 {
19890 PyThreadState* __tstate = wxPyBeginAllowThreads();
19891 result = (bool)(arg1)->ShiftDown();
19892 wxPyEndAllowThreads(__tstate);
19893 if (PyErr_Occurred()) SWIG_fail;
19894 }
19895 {
19896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19897 }
19898 return resultobj;
19899 fail:
19900 return NULL;
19901 }
19902
19903
19904 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19905 PyObject *resultobj = 0;
19906 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19907 bool result;
19908 void *argp1 = 0 ;
19909 int res1 = 0 ;
19910 PyObject *swig_obj[1] ;
19911
19912 if (!args) SWIG_fail;
19913 swig_obj[0] = args;
19914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19915 if (!SWIG_IsOK(res1)) {
19916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19917 }
19918 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 result = (bool)(arg1)->AltDown();
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 {
19926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19927 }
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19935 PyObject *resultobj = 0;
19936 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19937 bool result;
19938 void *argp1 = 0 ;
19939 int res1 = 0 ;
19940 PyObject *swig_obj[1] ;
19941
19942 if (!args) SWIG_fail;
19943 swig_obj[0] = args;
19944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19945 if (!SWIG_IsOK(res1)) {
19946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19947 }
19948 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19949 {
19950 PyThreadState* __tstate = wxPyBeginAllowThreads();
19951 result = (bool)(arg1)->CmdDown();
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 {
19956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19957 }
19958 return resultobj;
19959 fail:
19960 return NULL;
19961 }
19962
19963
19964 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19965 PyObject *obj;
19966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19967 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19968 return SWIG_Py_Void();
19969 }
19970
19971 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19972 return SWIG_Python_InitShadowInstance(args);
19973 }
19974
19975 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19976 PyObject *resultobj = 0;
19977 int arg1 ;
19978 wxEventType arg2 ;
19979 wxGrid *arg3 = (wxGrid *) 0 ;
19980 wxGridCellCoords *arg4 = 0 ;
19981 wxGridCellCoords *arg5 = 0 ;
19982 bool arg6 = (bool) true ;
19983 bool arg7 = (bool) false ;
19984 bool arg8 = (bool) false ;
19985 bool arg9 = (bool) false ;
19986 bool arg10 = (bool) false ;
19987 wxGridRangeSelectEvent *result = 0 ;
19988 int val1 ;
19989 int ecode1 = 0 ;
19990 int val2 ;
19991 int ecode2 = 0 ;
19992 void *argp3 = 0 ;
19993 int res3 = 0 ;
19994 wxGridCellCoords temp4 ;
19995 wxGridCellCoords temp5 ;
19996 bool val6 ;
19997 int ecode6 = 0 ;
19998 bool val7 ;
19999 int ecode7 = 0 ;
20000 bool val8 ;
20001 int ecode8 = 0 ;
20002 bool val9 ;
20003 int ecode9 = 0 ;
20004 bool val10 ;
20005 int ecode10 = 0 ;
20006 PyObject * obj0 = 0 ;
20007 PyObject * obj1 = 0 ;
20008 PyObject * obj2 = 0 ;
20009 PyObject * obj3 = 0 ;
20010 PyObject * obj4 = 0 ;
20011 PyObject * obj5 = 0 ;
20012 PyObject * obj6 = 0 ;
20013 PyObject * obj7 = 0 ;
20014 PyObject * obj8 = 0 ;
20015 PyObject * obj9 = 0 ;
20016 char * kwnames[] = {
20017 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
20018 };
20019
20020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
20021 ecode1 = SWIG_AsVal_int(obj0, &val1);
20022 if (!SWIG_IsOK(ecode1)) {
20023 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
20024 }
20025 arg1 = static_cast< int >(val1);
20026 ecode2 = SWIG_AsVal_int(obj1, &val2);
20027 if (!SWIG_IsOK(ecode2)) {
20028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20029 }
20030 arg2 = static_cast< wxEventType >(val2);
20031 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
20032 if (!SWIG_IsOK(res3)) {
20033 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
20034 }
20035 arg3 = reinterpret_cast< wxGrid * >(argp3);
20036 {
20037 arg4 = &temp4;
20038 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
20039 }
20040 {
20041 arg5 = &temp5;
20042 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
20043 }
20044 if (obj5) {
20045 ecode6 = SWIG_AsVal_bool(obj5, &val6);
20046 if (!SWIG_IsOK(ecode6)) {
20047 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
20048 }
20049 arg6 = static_cast< bool >(val6);
20050 }
20051 if (obj6) {
20052 ecode7 = SWIG_AsVal_bool(obj6, &val7);
20053 if (!SWIG_IsOK(ecode7)) {
20054 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
20055 }
20056 arg7 = static_cast< bool >(val7);
20057 }
20058 if (obj7) {
20059 ecode8 = SWIG_AsVal_bool(obj7, &val8);
20060 if (!SWIG_IsOK(ecode8)) {
20061 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
20062 }
20063 arg8 = static_cast< bool >(val8);
20064 }
20065 if (obj8) {
20066 ecode9 = SWIG_AsVal_bool(obj8, &val9);
20067 if (!SWIG_IsOK(ecode9)) {
20068 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
20069 }
20070 arg9 = static_cast< bool >(val9);
20071 }
20072 if (obj9) {
20073 ecode10 = SWIG_AsVal_bool(obj9, &val10);
20074 if (!SWIG_IsOK(ecode10)) {
20075 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
20076 }
20077 arg10 = static_cast< bool >(val10);
20078 }
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
20086 return resultobj;
20087 fail:
20088 return NULL;
20089 }
20090
20091
20092 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20093 PyObject *resultobj = 0;
20094 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20095 wxGridCellCoords result;
20096 void *argp1 = 0 ;
20097 int res1 = 0 ;
20098 PyObject *swig_obj[1] ;
20099
20100 if (!args) SWIG_fail;
20101 swig_obj[0] = args;
20102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20103 if (!SWIG_IsOK(res1)) {
20104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20105 }
20106 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20107 {
20108 PyThreadState* __tstate = wxPyBeginAllowThreads();
20109 result = (arg1)->GetTopLeftCoords();
20110 wxPyEndAllowThreads(__tstate);
20111 if (PyErr_Occurred()) SWIG_fail;
20112 }
20113 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20114 return resultobj;
20115 fail:
20116 return NULL;
20117 }
20118
20119
20120 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20121 PyObject *resultobj = 0;
20122 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20123 wxGridCellCoords result;
20124 void *argp1 = 0 ;
20125 int res1 = 0 ;
20126 PyObject *swig_obj[1] ;
20127
20128 if (!args) SWIG_fail;
20129 swig_obj[0] = args;
20130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20131 if (!SWIG_IsOK(res1)) {
20132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20133 }
20134 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20135 {
20136 PyThreadState* __tstate = wxPyBeginAllowThreads();
20137 result = (arg1)->GetBottomRightCoords();
20138 wxPyEndAllowThreads(__tstate);
20139 if (PyErr_Occurred()) SWIG_fail;
20140 }
20141 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20142 return resultobj;
20143 fail:
20144 return NULL;
20145 }
20146
20147
20148 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20149 PyObject *resultobj = 0;
20150 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20151 int result;
20152 void *argp1 = 0 ;
20153 int res1 = 0 ;
20154 PyObject *swig_obj[1] ;
20155
20156 if (!args) SWIG_fail;
20157 swig_obj[0] = args;
20158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20159 if (!SWIG_IsOK(res1)) {
20160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20161 }
20162 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20163 {
20164 PyThreadState* __tstate = wxPyBeginAllowThreads();
20165 result = (int)(arg1)->GetTopRow();
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_From_int(static_cast< int >(result));
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20177 PyObject *resultobj = 0;
20178 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20179 int result;
20180 void *argp1 = 0 ;
20181 int res1 = 0 ;
20182 PyObject *swig_obj[1] ;
20183
20184 if (!args) SWIG_fail;
20185 swig_obj[0] = args;
20186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20187 if (!SWIG_IsOK(res1)) {
20188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20189 }
20190 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (int)(arg1)->GetBottomRow();
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 resultobj = SWIG_From_int(static_cast< int >(result));
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20205 PyObject *resultobj = 0;
20206 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20207 int result;
20208 void *argp1 = 0 ;
20209 int res1 = 0 ;
20210 PyObject *swig_obj[1] ;
20211
20212 if (!args) SWIG_fail;
20213 swig_obj[0] = args;
20214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20215 if (!SWIG_IsOK(res1)) {
20216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20217 }
20218 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (int)(arg1)->GetLeftCol();
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 resultobj = SWIG_From_int(static_cast< int >(result));
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20233 PyObject *resultobj = 0;
20234 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20235 int result;
20236 void *argp1 = 0 ;
20237 int res1 = 0 ;
20238 PyObject *swig_obj[1] ;
20239
20240 if (!args) SWIG_fail;
20241 swig_obj[0] = args;
20242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20243 if (!SWIG_IsOK(res1)) {
20244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20245 }
20246 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20247 {
20248 PyThreadState* __tstate = wxPyBeginAllowThreads();
20249 result = (int)(arg1)->GetRightCol();
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 resultobj = SWIG_From_int(static_cast< int >(result));
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20261 PyObject *resultobj = 0;
20262 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20263 bool result;
20264 void *argp1 = 0 ;
20265 int res1 = 0 ;
20266 PyObject *swig_obj[1] ;
20267
20268 if (!args) SWIG_fail;
20269 swig_obj[0] = args;
20270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20271 if (!SWIG_IsOK(res1)) {
20272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20273 }
20274 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20275 {
20276 PyThreadState* __tstate = wxPyBeginAllowThreads();
20277 result = (bool)(arg1)->Selecting();
20278 wxPyEndAllowThreads(__tstate);
20279 if (PyErr_Occurred()) SWIG_fail;
20280 }
20281 {
20282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20283 }
20284 return resultobj;
20285 fail:
20286 return NULL;
20287 }
20288
20289
20290 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20291 PyObject *resultobj = 0;
20292 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20293 bool result;
20294 void *argp1 = 0 ;
20295 int res1 = 0 ;
20296 PyObject *swig_obj[1] ;
20297
20298 if (!args) SWIG_fail;
20299 swig_obj[0] = args;
20300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20301 if (!SWIG_IsOK(res1)) {
20302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20303 }
20304 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 result = (bool)(arg1)->ControlDown();
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 {
20312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20313 }
20314 return resultobj;
20315 fail:
20316 return NULL;
20317 }
20318
20319
20320 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20321 PyObject *resultobj = 0;
20322 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20323 bool result;
20324 void *argp1 = 0 ;
20325 int res1 = 0 ;
20326 PyObject *swig_obj[1] ;
20327
20328 if (!args) SWIG_fail;
20329 swig_obj[0] = args;
20330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20331 if (!SWIG_IsOK(res1)) {
20332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20333 }
20334 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 result = (bool)(arg1)->MetaDown();
20338 wxPyEndAllowThreads(__tstate);
20339 if (PyErr_Occurred()) SWIG_fail;
20340 }
20341 {
20342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20343 }
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20351 PyObject *resultobj = 0;
20352 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20353 bool result;
20354 void *argp1 = 0 ;
20355 int res1 = 0 ;
20356 PyObject *swig_obj[1] ;
20357
20358 if (!args) SWIG_fail;
20359 swig_obj[0] = args;
20360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20361 if (!SWIG_IsOK(res1)) {
20362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20363 }
20364 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 result = (bool)(arg1)->ShiftDown();
20368 wxPyEndAllowThreads(__tstate);
20369 if (PyErr_Occurred()) SWIG_fail;
20370 }
20371 {
20372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20373 }
20374 return resultobj;
20375 fail:
20376 return NULL;
20377 }
20378
20379
20380 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20381 PyObject *resultobj = 0;
20382 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20383 bool result;
20384 void *argp1 = 0 ;
20385 int res1 = 0 ;
20386 PyObject *swig_obj[1] ;
20387
20388 if (!args) SWIG_fail;
20389 swig_obj[0] = args;
20390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20391 if (!SWIG_IsOK(res1)) {
20392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20393 }
20394 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 result = (bool)(arg1)->AltDown();
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 {
20402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20403 }
20404 return resultobj;
20405 fail:
20406 return NULL;
20407 }
20408
20409
20410 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20411 PyObject *resultobj = 0;
20412 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20413 bool result;
20414 void *argp1 = 0 ;
20415 int res1 = 0 ;
20416 PyObject *swig_obj[1] ;
20417
20418 if (!args) SWIG_fail;
20419 swig_obj[0] = args;
20420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20421 if (!SWIG_IsOK(res1)) {
20422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20423 }
20424 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20425 {
20426 PyThreadState* __tstate = wxPyBeginAllowThreads();
20427 result = (bool)(arg1)->CmdDown();
20428 wxPyEndAllowThreads(__tstate);
20429 if (PyErr_Occurred()) SWIG_fail;
20430 }
20431 {
20432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20433 }
20434 return resultobj;
20435 fail:
20436 return NULL;
20437 }
20438
20439
20440 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20441 PyObject *obj;
20442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20443 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20444 return SWIG_Py_Void();
20445 }
20446
20447 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 return SWIG_Python_InitShadowInstance(args);
20449 }
20450
20451 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20452 PyObject *resultobj = 0;
20453 int arg1 ;
20454 wxEventType arg2 ;
20455 wxObject *arg3 = (wxObject *) 0 ;
20456 int arg4 ;
20457 int arg5 ;
20458 wxControl *arg6 = (wxControl *) 0 ;
20459 wxGridEditorCreatedEvent *result = 0 ;
20460 int val1 ;
20461 int ecode1 = 0 ;
20462 int val2 ;
20463 int ecode2 = 0 ;
20464 void *argp3 = 0 ;
20465 int res3 = 0 ;
20466 int val4 ;
20467 int ecode4 = 0 ;
20468 int val5 ;
20469 int ecode5 = 0 ;
20470 void *argp6 = 0 ;
20471 int res6 = 0 ;
20472 PyObject * obj0 = 0 ;
20473 PyObject * obj1 = 0 ;
20474 PyObject * obj2 = 0 ;
20475 PyObject * obj3 = 0 ;
20476 PyObject * obj4 = 0 ;
20477 PyObject * obj5 = 0 ;
20478 char * kwnames[] = {
20479 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20480 };
20481
20482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20483 ecode1 = SWIG_AsVal_int(obj0, &val1);
20484 if (!SWIG_IsOK(ecode1)) {
20485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20486 }
20487 arg1 = static_cast< int >(val1);
20488 ecode2 = SWIG_AsVal_int(obj1, &val2);
20489 if (!SWIG_IsOK(ecode2)) {
20490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20491 }
20492 arg2 = static_cast< wxEventType >(val2);
20493 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20494 if (!SWIG_IsOK(res3)) {
20495 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20496 }
20497 arg3 = reinterpret_cast< wxObject * >(argp3);
20498 ecode4 = SWIG_AsVal_int(obj3, &val4);
20499 if (!SWIG_IsOK(ecode4)) {
20500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20501 }
20502 arg4 = static_cast< int >(val4);
20503 ecode5 = SWIG_AsVal_int(obj4, &val5);
20504 if (!SWIG_IsOK(ecode5)) {
20505 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20506 }
20507 arg5 = static_cast< int >(val5);
20508 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20509 if (!SWIG_IsOK(res6)) {
20510 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20511 }
20512 arg6 = reinterpret_cast< wxControl * >(argp6);
20513 {
20514 PyThreadState* __tstate = wxPyBeginAllowThreads();
20515 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20516 wxPyEndAllowThreads(__tstate);
20517 if (PyErr_Occurred()) SWIG_fail;
20518 }
20519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20520 return resultobj;
20521 fail:
20522 return NULL;
20523 }
20524
20525
20526 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20527 PyObject *resultobj = 0;
20528 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20529 int result;
20530 void *argp1 = 0 ;
20531 int res1 = 0 ;
20532 PyObject *swig_obj[1] ;
20533
20534 if (!args) SWIG_fail;
20535 swig_obj[0] = args;
20536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20537 if (!SWIG_IsOK(res1)) {
20538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20539 }
20540 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20541 {
20542 PyThreadState* __tstate = wxPyBeginAllowThreads();
20543 result = (int)(arg1)->GetRow();
20544 wxPyEndAllowThreads(__tstate);
20545 if (PyErr_Occurred()) SWIG_fail;
20546 }
20547 resultobj = SWIG_From_int(static_cast< int >(result));
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20555 PyObject *resultobj = 0;
20556 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20557 int result;
20558 void *argp1 = 0 ;
20559 int res1 = 0 ;
20560 PyObject *swig_obj[1] ;
20561
20562 if (!args) SWIG_fail;
20563 swig_obj[0] = args;
20564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20565 if (!SWIG_IsOK(res1)) {
20566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20567 }
20568 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20569 {
20570 PyThreadState* __tstate = wxPyBeginAllowThreads();
20571 result = (int)(arg1)->GetCol();
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 resultobj = SWIG_From_int(static_cast< int >(result));
20576 return resultobj;
20577 fail:
20578 return NULL;
20579 }
20580
20581
20582 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20583 PyObject *resultobj = 0;
20584 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20585 wxControl *result = 0 ;
20586 void *argp1 = 0 ;
20587 int res1 = 0 ;
20588 PyObject *swig_obj[1] ;
20589
20590 if (!args) SWIG_fail;
20591 swig_obj[0] = args;
20592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20593 if (!SWIG_IsOK(res1)) {
20594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20595 }
20596 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (wxControl *)(arg1)->GetControl();
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 {
20604 resultobj = wxPyMake_wxObject(result, 0);
20605 }
20606 return resultobj;
20607 fail:
20608 return NULL;
20609 }
20610
20611
20612 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20613 PyObject *resultobj = 0;
20614 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20615 int arg2 ;
20616 void *argp1 = 0 ;
20617 int res1 = 0 ;
20618 int val2 ;
20619 int ecode2 = 0 ;
20620 PyObject * obj0 = 0 ;
20621 PyObject * obj1 = 0 ;
20622 char * kwnames[] = {
20623 (char *) "self",(char *) "row", NULL
20624 };
20625
20626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20628 if (!SWIG_IsOK(res1)) {
20629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20630 }
20631 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20632 ecode2 = SWIG_AsVal_int(obj1, &val2);
20633 if (!SWIG_IsOK(ecode2)) {
20634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20635 }
20636 arg2 = static_cast< int >(val2);
20637 {
20638 PyThreadState* __tstate = wxPyBeginAllowThreads();
20639 (arg1)->SetRow(arg2);
20640 wxPyEndAllowThreads(__tstate);
20641 if (PyErr_Occurred()) SWIG_fail;
20642 }
20643 resultobj = SWIG_Py_Void();
20644 return resultobj;
20645 fail:
20646 return NULL;
20647 }
20648
20649
20650 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj = 0;
20652 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20653 int arg2 ;
20654 void *argp1 = 0 ;
20655 int res1 = 0 ;
20656 int val2 ;
20657 int ecode2 = 0 ;
20658 PyObject * obj0 = 0 ;
20659 PyObject * obj1 = 0 ;
20660 char * kwnames[] = {
20661 (char *) "self",(char *) "col", NULL
20662 };
20663
20664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20666 if (!SWIG_IsOK(res1)) {
20667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20668 }
20669 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20670 ecode2 = SWIG_AsVal_int(obj1, &val2);
20671 if (!SWIG_IsOK(ecode2)) {
20672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20673 }
20674 arg2 = static_cast< int >(val2);
20675 {
20676 PyThreadState* __tstate = wxPyBeginAllowThreads();
20677 (arg1)->SetCol(arg2);
20678 wxPyEndAllowThreads(__tstate);
20679 if (PyErr_Occurred()) SWIG_fail;
20680 }
20681 resultobj = SWIG_Py_Void();
20682 return resultobj;
20683 fail:
20684 return NULL;
20685 }
20686
20687
20688 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20689 PyObject *resultobj = 0;
20690 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20691 wxControl *arg2 = (wxControl *) 0 ;
20692 void *argp1 = 0 ;
20693 int res1 = 0 ;
20694 void *argp2 = 0 ;
20695 int res2 = 0 ;
20696 PyObject * obj0 = 0 ;
20697 PyObject * obj1 = 0 ;
20698 char * kwnames[] = {
20699 (char *) "self",(char *) "ctrl", NULL
20700 };
20701
20702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20704 if (!SWIG_IsOK(res1)) {
20705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20706 }
20707 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20709 if (!SWIG_IsOK(res2)) {
20710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20711 }
20712 arg2 = reinterpret_cast< wxControl * >(argp2);
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 (arg1)->SetControl(arg2);
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 resultobj = SWIG_Py_Void();
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20727 PyObject *obj;
20728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20729 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20730 return SWIG_Py_Void();
20731 }
20732
20733 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20734 return SWIG_Python_InitShadowInstance(args);
20735 }
20736
20737 static PyMethodDef SwigMethods[] = {
20738 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20740 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20742 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20743 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20744 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20747 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20748 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20749 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20752 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20753 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20754 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20755 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20756 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20757 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20758 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20759 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20761 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20763 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20765 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20766 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20767 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20768 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20769 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20771 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20772 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20774 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20775 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20776 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20777 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20778 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20779 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20780 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20782 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20787 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20788 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20794 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20796 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20797 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20798 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20801 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20802 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20803 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20804 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20805 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20806 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20808 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20809 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20811 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20812 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20813 { (char *)"GridCellBoolEditor_UseStringValues", (PyCFunction) _wrap_GridCellBoolEditor_UseStringValues, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"GridCellBoolEditor_IsTrueValue", (PyCFunction) _wrap_GridCellBoolEditor_IsTrueValue, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20816 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20817 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20819 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20820 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20822 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20823 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20824 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20825 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20826 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20829 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20830 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20832 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20833 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20844 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20845 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20846 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20847 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20848 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20849 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20850 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20851 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20852 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20853 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20854 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20855 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20856 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20857 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20860 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20861 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20863 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20864 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20865 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20873 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20874 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20875 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20881 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20882 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20883 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20886 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20888 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20889 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20890 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20903 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20914 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20919 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20920 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20922 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20923 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20924 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20926 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20927 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20929 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20931 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20933 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20935 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20937 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20938 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20939 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20941 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20942 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20944 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20949 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20950 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20951 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20953 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20957 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20958 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20959 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20961 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20963 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20973 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20974 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20975 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20976 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20977 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20980 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20981 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20982 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20983 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20984 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20985 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20986 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20987 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20994 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20995 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
21003 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
21004 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
21009 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
21010 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
21011 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
21012 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
21013 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
21014 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
21015 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
21016 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
21017 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
21018 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
21020 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
21021 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
21022 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
21025 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
21026 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
21027 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
21038 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
21042 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
21043 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
21044 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
21046 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
21047 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
21049 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
21050 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
21051 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
21052 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
21053 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
21054 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
21055 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
21056 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
21057 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
21058 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
21059 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
21061 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
21063 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
21064 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
21065 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
21066 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
21067 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
21068 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
21069 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
21071 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
21073 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
21074 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
21075 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
21076 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
21077 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21078 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
21079 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
21080 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
21081 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
21082 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
21083 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
21084 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
21085 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
21089 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
21093 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21096 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21097 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21098 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21099 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
21100 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
21101 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
21102 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
21103 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
21104 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
21105 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
21106 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
21107 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21108 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
21109 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
21110 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
21111 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
21112 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21113 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21114 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
21115 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21116 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21117 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21118 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
21119 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21120 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21121 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21122 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21123 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21124 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21125 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21126 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21127 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
21128 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
21129 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
21130 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
21131 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
21132 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
21133 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
21134 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
21135 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
21136 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21137 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21138 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
21139 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
21140 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
21141 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
21142 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21143 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21144 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
21145 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21146 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21147 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
21148 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
21149 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
21150 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
21151 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
21152 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
21153 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
21154 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
21155 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
21156 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
21157 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
21158 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
21159 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
21160 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
21161 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
21162 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
21163 { (char *)"new_GridUpdateLocker", (PyCFunction) _wrap_new_GridUpdateLocker, METH_VARARGS | METH_KEYWORDS, NULL},
21164 { (char *)"delete_GridUpdateLocker", (PyCFunction)_wrap_delete_GridUpdateLocker, METH_O, NULL},
21165 { (char *)"GridUpdateLocker_Create", (PyCFunction) _wrap_GridUpdateLocker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
21166 { (char *)"GridUpdateLocker_swigregister", GridUpdateLocker_swigregister, METH_VARARGS, NULL},
21167 { (char *)"GridUpdateLocker_swiginit", GridUpdateLocker_swiginit, METH_VARARGS, NULL},
21168 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21169 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
21170 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
21171 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
21172 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
21173 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
21174 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
21175 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
21176 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
21177 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
21178 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
21179 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
21180 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21181 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
21182 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
21183 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
21184 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
21185 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
21186 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
21187 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
21188 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
21189 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
21190 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21191 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
21192 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
21193 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
21194 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
21195 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
21196 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
21197 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
21198 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
21199 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
21200 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
21201 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
21202 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
21203 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
21204 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
21205 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21206 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
21207 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
21208 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
21209 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
21210 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
21211 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
21212 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
21213 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
21214 { NULL, NULL, 0, NULL }
21215 };
21216
21217
21218 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21219
21220 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
21221 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21222 }
21223 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
21224 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21225 }
21226 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
21227 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21228 }
21229 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
21230 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21231 }
21232 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
21233 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21234 }
21235 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
21236 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21237 }
21238 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
21239 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21240 }
21241 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
21242 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21243 }
21244 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
21245 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21246 }
21247 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
21248 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21249 }
21250 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
21251 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21252 }
21253 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
21254 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21255 }
21256 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
21257 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21258 }
21259 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
21260 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21261 }
21262 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
21263 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21264 }
21265 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
21266 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21267 }
21268 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
21269 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21270 }
21271 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
21272 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21273 }
21274 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
21275 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21276 }
21277 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
21278 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21279 }
21280 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
21281 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
21282 }
21283 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
21284 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21285 }
21286 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
21287 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21288 }
21289 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
21290 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21291 }
21292 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
21293 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21294 }
21295 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
21296 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21297 }
21298 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
21299 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21300 }
21301 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
21302 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21303 }
21304 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
21305 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21306 }
21307 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
21308 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21309 }
21310 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
21311 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
21312 }
21313 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
21314 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
21315 }
21316 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
21317 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
21318 }
21319 static void *_p_wxPyHScrolledWindowTo_p_wxPanel(void *x) {
21320 return (void *)((wxPanel *) ((wxPyHScrolledWindow *) x));
21321 }
21322 static void *_p_wxPyHVScrolledWindowTo_p_wxPanel(void *x) {
21323 return (void *)((wxPanel *) ((wxPyHVScrolledWindow *) x));
21324 }
21325 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
21326 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21327 }
21328 static void *_p_wxGridTo_p_wxPanel(void *x) {
21329 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
21330 }
21331 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
21332 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21333 }
21334 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
21335 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21336 }
21337 static void *_p_wxSimpleHtmlListBoxTo_p_wxPanel(void *x) {
21338 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21339 }
21340 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
21341 return (void *)((wxPanel *) ((wxPyPanel *) x));
21342 }
21343 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
21344 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
21345 }
21346 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
21347 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
21348 }
21349 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
21350 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21351 }
21352 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
21353 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
21354 }
21355 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
21356 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21357 }
21358 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
21359 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
21360 }
21361 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
21362 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
21363 }
21364 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
21365 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21366 }
21367 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
21368 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
21369 }
21370 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
21371 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
21372 }
21373 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
21374 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21375 }
21376 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
21377 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21378 }
21379 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
21380 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
21381 }
21382 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21383 return (void *)((wxWindow *) ((wxMenuBar *) x));
21384 }
21385 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21386 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21387 }
21388 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21389 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21390 }
21391 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21392 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21393 }
21394 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21395 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21396 }
21397 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21398 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21399 }
21400 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21401 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21402 }
21403 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21404 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21405 }
21406 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21407 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21408 }
21409 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21410 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21411 }
21412 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21413 return (void *)((wxWindow *) ((wxPanel *) x));
21414 }
21415 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21416 return (void *)((wxWindow *) ((wxStatusBar *) x));
21417 }
21418 static void *_p_wxPyHVScrolledWindowTo_p_wxWindow(void *x) {
21419 return (void *)((wxWindow *) (wxPanel *) ((wxPyHVScrolledWindow *) x));
21420 }
21421 static void *_p_wxPyHScrolledWindowTo_p_wxWindow(void *x) {
21422 return (void *)((wxWindow *) (wxPanel *) ((wxPyHScrolledWindow *) x));
21423 }
21424 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21425 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21426 }
21427 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21428 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21429 }
21430 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21431 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21432 }
21433 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21434 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21435 }
21436 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21437 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21438 }
21439 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21440 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21441 }
21442 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21443 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21444 }
21445 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21446 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21447 }
21448 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21449 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21450 }
21451 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21452 return (void *)((wxWindow *) ((wxSashWindow *) x));
21453 }
21454 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21455 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21456 }
21457 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21458 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21459 }
21460 static void *_p_wxControlTo_p_wxWindow(void *x) {
21461 return (void *)((wxWindow *) ((wxControl *) x));
21462 }
21463 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21464 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21465 }
21466 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21467 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21468 }
21469 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21470 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21471 }
21472 static void *_p_wxGridTo_p_wxWindow(void *x) {
21473 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21474 }
21475 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21476 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21477 }
21478 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21479 return (void *)((wxWindow *) ((wxPyWindow *) x));
21480 }
21481 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21482 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21483 }
21484 static void *_p_wxSimpleHtmlListBoxTo_p_wxWindow(void *x) {
21485 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21486 }
21487 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21488 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21489 }
21490 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21491 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21492 }
21493 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21494 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21495 }
21496 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21497 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21498 }
21499 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21500 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21501 }
21502 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21503 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21504 }
21505 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21506 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21507 }
21508 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21509 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21510 }
21511 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21512 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21513 }
21514 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21515 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21516 }
21517 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21518 return (void *)((wxControl *) ((wxControlWithItems *) x));
21519 }
21520 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21521 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21522 }
21523 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21524 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21525 }
21526 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21527 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21528 }
21529 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21530 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21531 }
21532 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21533 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21534 }
21535 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21536 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21537 }
21538 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21539 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21540 }
21541 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21542 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21543 }
21544 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21545 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21546 }
21547 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21548 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21549 }
21550 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21551 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21552 }
21553 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21554 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21555 }
21556 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21557 return (void *)((wxEvent *) ((wxPyEvent *) x));
21558 }
21559 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21560 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21561 }
21562 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21563 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21564 }
21565 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21566 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21567 }
21568 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21569 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21570 }
21571 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21572 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21573 }
21574 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21575 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21576 }
21577 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21578 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21579 }
21580 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21581 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21582 }
21583 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21584 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21585 }
21586 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21587 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21588 }
21589 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21590 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21591 }
21592 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21593 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21594 }
21595 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21596 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21597 }
21598 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21599 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21600 }
21601 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21602 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21603 }
21604 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21605 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21606 }
21607 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21608 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21609 }
21610 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21611 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21612 }
21613 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21614 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21615 }
21616 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21617 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21618 }
21619 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21620 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21621 }
21622 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21623 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21624 }
21625 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21626 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21627 }
21628 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21629 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21630 }
21631 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21632 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21633 }
21634 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21635 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21636 }
21637 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21638 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21639 }
21640 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21641 return (void *)((wxEvent *) ((wxShowEvent *) x));
21642 }
21643 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21644 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21645 }
21646 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21647 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21648 }
21649 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21650 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21651 }
21652 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21653 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21654 }
21655 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21656 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21657 }
21658 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21659 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21660 }
21661 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21662 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21663 }
21664 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21665 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21666 }
21667 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21668 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21669 }
21670 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
21671 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
21672 }
21673 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21674 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21675 }
21676 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21677 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21678 }
21679 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21680 return (void *)((wxObject *) ((wxSizerItem *) x));
21681 }
21682 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21683 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21684 }
21685 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21686 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21687 }
21688 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21689 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21690 }
21691 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21692 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21693 }
21694 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21695 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21696 }
21697 static void *_p_wxSizerTo_p_wxObject(void *x) {
21698 return (void *)((wxObject *) ((wxSizer *) x));
21699 }
21700 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21701 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21702 }
21703 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21704 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21705 }
21706 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21707 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21708 }
21709 static void *_p_wxEventTo_p_wxObject(void *x) {
21710 return (void *)((wxObject *) ((wxEvent *) x));
21711 }
21712 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21713 return (void *)((wxObject *) ((wxFontData *) x));
21714 }
21715 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21716 return (void *)((wxObject *) ((wxPrintData *) x));
21717 }
21718 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21719 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21720 }
21721 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21722 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21723 }
21724 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21725 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21726 }
21727 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21728 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21729 }
21730 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21731 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21732 }
21733 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21734 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21735 }
21736 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21737 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21738 }
21739 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21740 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21741 }
21742 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21743 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21744 }
21745 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21746 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21747 }
21748 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21749 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21750 }
21751 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21752 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21753 }
21754 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21755 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21756 }
21757 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21758 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21759 }
21760 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21761 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21762 }
21763 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21764 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21765 }
21766 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21767 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21768 }
21769 static void *_p_wxControlTo_p_wxObject(void *x) {
21770 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21771 }
21772 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21773 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21774 }
21775 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21776 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21777 }
21778 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21779 return (void *)((wxObject *) ((wxFSFile *) x));
21780 }
21781 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21782 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21783 }
21784 static void *_p_wxGridTo_p_wxObject(void *x) {
21785 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21786 }
21787 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21788 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21789 }
21790 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21791 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21792 }
21793 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21794 return (void *)((wxObject *) ((wxColourData *) x));
21795 }
21796 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21797 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21798 }
21799 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21800 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21801 }
21802 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21803 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21804 }
21805 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21806 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21807 }
21808 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21809 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21810 }
21811 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21812 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21813 }
21814 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21815 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21816 }
21817 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21818 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21819 }
21820 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21821 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21822 }
21823 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21824 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21825 }
21826 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21827 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21828 }
21829 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21830 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21831 }
21832 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21833 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21834 }
21835 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21836 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21837 }
21838 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21839 return (void *)((wxObject *) ((wxPrinter *) x));
21840 }
21841 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21842 return (void *)((wxObject *) ((wxMenuItem *) x));
21843 }
21844 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21845 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21846 }
21847 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21848 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21849 }
21850 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21851 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21852 }
21853 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21854 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21855 }
21856 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21857 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21858 }
21859 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21860 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21861 }
21862 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21863 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21864 }
21865 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21866 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21867 }
21868 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21869 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21870 }
21871 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21872 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21873 }
21874 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21875 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21876 }
21877 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21878 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21879 }
21880 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21881 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21882 }
21883 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21884 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21885 }
21886 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21887 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21888 }
21889 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21890 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21891 }
21892 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21893 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21894 }
21895 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21896 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21897 }
21898 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21899 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21900 }
21901 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21902 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21903 }
21904 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21905 return (void *)((wxObject *) ((wxImageHandler *) x));
21906 }
21907 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21908 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21909 }
21910 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21911 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21912 }
21913 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
21914 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
21915 }
21916 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21917 return (void *)((wxObject *) ((wxEvtHandler *) x));
21918 }
21919 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21920 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21921 }
21922 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21923 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21924 }
21925 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21926 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21927 }
21928 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21929 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21930 }
21931 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21932 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21933 }
21934 static void *_p_wxSimpleHtmlListBoxTo_p_wxObject(void *x) {
21935 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21936 }
21937 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21938 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21939 }
21940 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21941 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21942 }
21943 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21944 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21945 }
21946 static void *_p_wxImageTo_p_wxObject(void *x) {
21947 return (void *)((wxObject *) ((wxImage *) x));
21948 }
21949 static void *_p_wxFrameTo_p_wxObject(void *x) {
21950 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21951 }
21952 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21953 return (void *)((wxObject *) ((wxPyPrintout *) x));
21954 }
21955 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21956 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21957 }
21958 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21959 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21960 }
21961 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21962 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21963 }
21964 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21965 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21966 }
21967 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21968 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21969 }
21970 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21971 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21972 }
21973 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21974 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21975 }
21976 static void *_p_wxWindowTo_p_wxObject(void *x) {
21977 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21978 }
21979 static void *_p_wxMenuTo_p_wxObject(void *x) {
21980 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21981 }
21982 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21983 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21984 }
21985 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21986 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21987 }
21988 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21989 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21990 }
21991 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21992 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21993 }
21994 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21995 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21996 }
21997 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21998 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21999 }
22000 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
22001 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
22002 }
22003 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
22004 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
22005 }
22006 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
22007 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
22008 }
22009 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
22010 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
22011 }
22012 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
22013 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22014 }
22015 static void *_p_wxPyHScrolledWindowTo_p_wxObject(void *x) {
22016 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyHScrolledWindow *) x));
22017 }
22018 static void *_p_wxPyHVScrolledWindowTo_p_wxObject(void *x) {
22019 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyHVScrolledWindow *) x));
22020 }
22021 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
22022 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
22023 }
22024 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
22025 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22026 }
22027 static void *_p_wxSashEventTo_p_wxObject(void *x) {
22028 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
22029 }
22030 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
22031 return (void *)((wxObject *) ((wxPrintPreview *) x));
22032 }
22033 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
22034 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
22035 }
22036 static void *_p_wxPanelTo_p_wxObject(void *x) {
22037 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
22038 }
22039 static void *_p_wxDialogTo_p_wxObject(void *x) {
22040 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22041 }
22042 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
22043 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22044 }
22045 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
22046 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22047 }
22048 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
22049 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22050 }
22051 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
22052 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
22053 }
22054 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
22055 return (void *)((wxObject *) ((wxPrintDialog *) x));
22056 }
22057 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22058 return (void *)((wxObject *) ((wxFileSystem *) x));
22059 }
22060 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22061 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22062 }
22063 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22064 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22065 }
22066 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22067 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22068 }
22069 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22070 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22071 }
22072 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22073 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22074 }
22075 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22076 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22077 }
22078 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
22079 return (void *)((wxObject *) ((wxGridTableBase *) x));
22080 }
22081 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
22082 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
22083 }
22084 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22085 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22086 }
22087 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22088 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22089 }
22090 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
22091 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22092 }
22093 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
22094 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22095 }
22096 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22097 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22098 }
22099 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22100 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22101 }
22102 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22103 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22104 }
22105 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22106 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22107 }
22108 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
22109 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
22110 }
22111 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
22112 return (void *)((wxObject *) ((wxPrintDialogData *) x));
22113 }
22114 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22115 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22116 }
22117 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22118 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22119 }
22120 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
22121 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
22122 }
22123 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
22124 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
22125 }
22126 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
22127 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
22128 }
22129 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
22130 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
22131 }
22132 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
22133 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
22134 }
22135 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
22136 return (void *)((wxEvtHandler *) ((wxValidator *) x));
22137 }
22138 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
22139 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
22140 }
22141 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
22142 return (void *)((wxEvtHandler *) ((wxMenu *) x));
22143 }
22144 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
22145 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
22146 }
22147 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
22148 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
22149 }
22150 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
22151 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
22152 }
22153 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
22154 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
22155 }
22156 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
22157 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
22158 }
22159 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
22160 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
22161 }
22162 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
22163 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
22164 }
22165 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
22166 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
22167 }
22168 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
22169 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
22170 }
22171 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
22172 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
22173 }
22174 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
22175 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
22176 }
22177 static void *_p_wxPyHVScrolledWindowTo_p_wxEvtHandler(void *x) {
22178 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyHVScrolledWindow *) x));
22179 }
22180 static void *_p_wxPyHScrolledWindowTo_p_wxEvtHandler(void *x) {
22181 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyHScrolledWindow *) x));
22182 }
22183 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
22184 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22185 }
22186 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
22187 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
22188 }
22189 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
22190 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
22191 }
22192 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
22193 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
22194 }
22195 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
22196 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
22197 }
22198 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
22199 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
22200 }
22201 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
22202 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
22203 }
22204 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
22205 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
22206 }
22207 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
22208 return (void *)((wxEvtHandler *) ((wxWindow *) x));
22209 }
22210 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
22211 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
22212 }
22213 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
22214 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
22215 }
22216 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
22217 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
22218 }
22219 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
22220 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22221 }
22222 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
22223 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
22224 }
22225 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
22226 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
22227 }
22228 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
22229 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
22230 }
22231 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
22232 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
22233 }
22234 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
22235 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
22236 }
22237 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
22238 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
22239 }
22240 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
22241 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22242 }
22243 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
22244 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
22245 }
22246 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
22247 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
22248 }
22249 static void *_p_wxSimpleHtmlListBoxTo_p_wxEvtHandler(void *x) {
22250 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
22251 }
22252 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
22253 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
22254 }
22255 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
22256 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
22257 }
22258 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
22259 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22260 }
22261 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
22262 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22263 }
22264 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
22265 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
22266 }
22267 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
22268 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
22269 }
22270 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
22271 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22272 }
22273 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
22274 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22275 }
22276 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
22277 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22278 }
22279 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
22280 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22281 }
22282 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
22283 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
22284 }
22285 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
22286 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
22287 }
22288 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
22289 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
22290 }
22291 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
22292 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
22293 }
22294 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
22295 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
22296 }
22297 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
22298 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22299 }
22300 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
22301 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22302 }
22303 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
22304 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
22305 }
22306 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
22307 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
22308 }
22309 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
22310 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22311 }
22312 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
22313 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22314 }
22315 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
22316 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22317 }
22318 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
22319 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22320 }
22321 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
22322 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22323 }
22324 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
22325 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
22326 }
22327 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
22328 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22329 }
22330 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
22331 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
22332 }
22333 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
22334 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
22335 }
22336 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
22337 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
22338 }
22339 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
22340 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
22341 }
22342 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
22343 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
22344 }
22345 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
22346 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
22347 }
22348 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
22349 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
22350 }
22351 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
22352 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
22353 }
22354 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
22355 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
22356 }
22357 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
22358 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
22359 }
22360 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
22361 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
22362 }
22363 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
22364 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
22365 }
22366 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
22367 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
22368 }
22369 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
22370 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
22371 }
22372 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
22373 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
22374 }
22375 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
22376 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
22377 }
22378 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
22379 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22380 }
22381 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22382 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};
22383 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
22384 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
22385 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
22386 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
22387 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
22388 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
22389 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
22390 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
22391 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
22392 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
22393 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
22394 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
22395 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
22396 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
22397 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
22398 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
22399 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
22400 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
22401 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
22402 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
22403 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
22404 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
22405 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
22406 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
22407 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
22408 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
22409 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
22410 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
22411 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
22412 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
22413 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
22414 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
22415 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
22416 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
22417 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
22418 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
22419 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
22420 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22421 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22422 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22423 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22424 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22425 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22426 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22427 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22428 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22429 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22430 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22431 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22432 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22433 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22434 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22435 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22436 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22437 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22438 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22439 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22440 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22441 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
22442 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22443 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22444 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22445 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22446 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22447 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22448 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22449 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22450 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22451 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22452 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22453 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22454 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22455 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22456 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22457 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22458 static swig_type_info _swigt__p_wxPyHScrolledWindow = {"_p_wxPyHScrolledWindow", 0, 0, 0, 0, 0};
22459 static swig_type_info _swigt__p_wxPyHVScrolledWindow = {"_p_wxPyHVScrolledWindow", 0, 0, 0, 0, 0};
22460 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22461 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22462 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22463 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22464 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22465 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22466 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22467 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22468 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22469 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22470 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22471 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22472 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22473 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22474 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22475 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22476 static swig_type_info _swigt__p_wxSimpleHtmlListBox = {"_p_wxSimpleHtmlListBox", 0, 0, 0, 0, 0};
22477 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22478 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22479 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22480 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22481 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22482 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22483 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22484 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22485 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22486 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22487 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22488 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22489 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22490 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22491 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22492 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22493 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22494 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22495 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22496 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22497 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22498 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22499 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22500 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22501 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22502 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22503 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22504 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22505 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22506 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22507 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22508 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22509 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22510 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22511 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22512 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22513 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22514 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22515 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22516 static swig_type_info _swigt__p_wxGridUpdateLocker = {"_p_wxGridUpdateLocker", "wxGridUpdateLocker *", 0, 0, (void*)0, 0};
22517 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22518 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22519 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22520 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22521 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22522 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22523 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22524 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22525 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22526 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22527 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22528 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22529 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22530 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22531 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22532 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22533 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22534 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22535 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22536 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22537 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22538 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22539 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22540 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22541 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22542 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22543 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22544 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22545 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22546 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22547 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22548 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22549 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22550 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22551 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22552 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
22553 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22554 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22555 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22556 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22557 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22558 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22559 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22560 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22561 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22562 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22563 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22564 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22565 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22566 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22567 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22568 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22569 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22570 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22571 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22572 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22573 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22574 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
22575 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22576 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22577 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22578
22579 static swig_type_info *swig_type_initial[] = {
22580 &_swigt__p_char,
22581 &_swigt__p_form_ops_t,
22582 &_swigt__p_int,
22583 &_swigt__p_long,
22584 &_swigt__p_unsigned_char,
22585 &_swigt__p_unsigned_int,
22586 &_swigt__p_unsigned_long,
22587 &_swigt__p_wxANIHandler,
22588 &_swigt__p_wxAcceleratorTable,
22589 &_swigt__p_wxActivateEvent,
22590 &_swigt__p_wxArrayString,
22591 &_swigt__p_wxBMPHandler,
22592 &_swigt__p_wxBoxSizer,
22593 &_swigt__p_wxCURHandler,
22594 &_swigt__p_wxCalculateLayoutEvent,
22595 &_swigt__p_wxChildFocusEvent,
22596 &_swigt__p_wxClipboardTextEvent,
22597 &_swigt__p_wxCloseEvent,
22598 &_swigt__p_wxColour,
22599 &_swigt__p_wxColourData,
22600 &_swigt__p_wxColourDialog,
22601 &_swigt__p_wxCommandEvent,
22602 &_swigt__p_wxContextMenuEvent,
22603 &_swigt__p_wxControl,
22604 &_swigt__p_wxControlWithItems,
22605 &_swigt__p_wxDC,
22606 &_swigt__p_wxDateEvent,
22607 &_swigt__p_wxDialog,
22608 &_swigt__p_wxDirDialog,
22609 &_swigt__p_wxDisplayChangedEvent,
22610 &_swigt__p_wxDropFilesEvent,
22611 &_swigt__p_wxDuplexMode,
22612 &_swigt__p_wxEraseEvent,
22613 &_swigt__p_wxEvent,
22614 &_swigt__p_wxEventBlocker,
22615 &_swigt__p_wxEvtHandler,
22616 &_swigt__p_wxFSFile,
22617 &_swigt__p_wxFileDialog,
22618 &_swigt__p_wxFileSystem,
22619 &_swigt__p_wxFindDialogEvent,
22620 &_swigt__p_wxFindReplaceData,
22621 &_swigt__p_wxFindReplaceDialog,
22622 &_swigt__p_wxFlexGridSizer,
22623 &_swigt__p_wxFocusEvent,
22624 &_swigt__p_wxFont,
22625 &_swigt__p_wxFontData,
22626 &_swigt__p_wxFontDialog,
22627 &_swigt__p_wxFrame,
22628 &_swigt__p_wxGBSizerItem,
22629 &_swigt__p_wxGIFHandler,
22630 &_swigt__p_wxGrid,
22631 &_swigt__p_wxGridBagSizer,
22632 &_swigt__p_wxGridCellAttr,
22633 &_swigt__p_wxGridCellAttrProvider,
22634 &_swigt__p_wxGridCellAutoWrapStringEditor,
22635 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22636 &_swigt__p_wxGridCellBoolEditor,
22637 &_swigt__p_wxGridCellBoolRenderer,
22638 &_swigt__p_wxGridCellChoiceEditor,
22639 &_swigt__p_wxGridCellCoords,
22640 &_swigt__p_wxGridCellDateTimeRenderer,
22641 &_swigt__p_wxGridCellEditor,
22642 &_swigt__p_wxGridCellEnumEditor,
22643 &_swigt__p_wxGridCellEnumRenderer,
22644 &_swigt__p_wxGridCellFloatEditor,
22645 &_swigt__p_wxGridCellFloatRenderer,
22646 &_swigt__p_wxGridCellNumberEditor,
22647 &_swigt__p_wxGridCellNumberRenderer,
22648 &_swigt__p_wxGridCellRenderer,
22649 &_swigt__p_wxGridCellStringRenderer,
22650 &_swigt__p_wxGridCellTextEditor,
22651 &_swigt__p_wxGridCellWorker,
22652 &_swigt__p_wxGridEditorCreatedEvent,
22653 &_swigt__p_wxGridEvent,
22654 &_swigt__p_wxGridRangeSelectEvent,
22655 &_swigt__p_wxGridSizeEvent,
22656 &_swigt__p_wxGridSizer,
22657 &_swigt__p_wxGridStringTable,
22658 &_swigt__p_wxGridTableBase,
22659 &_swigt__p_wxGridTableMessage,
22660 &_swigt__p_wxGridUpdateLocker,
22661 &_swigt__p_wxICOHandler,
22662 &_swigt__p_wxIconizeEvent,
22663 &_swigt__p_wxIdleEvent,
22664 &_swigt__p_wxImage,
22665 &_swigt__p_wxImageHandler,
22666 &_swigt__p_wxIndividualLayoutConstraint,
22667 &_swigt__p_wxInitDialogEvent,
22668 &_swigt__p_wxJPEGHandler,
22669 &_swigt__p_wxKeyEvent,
22670 &_swigt__p_wxLayoutAlgorithm,
22671 &_swigt__p_wxLayoutConstraints,
22672 &_swigt__p_wxMDIChildFrame,
22673 &_swigt__p_wxMDIClientWindow,
22674 &_swigt__p_wxMDIParentFrame,
22675 &_swigt__p_wxMaximizeEvent,
22676 &_swigt__p_wxMenu,
22677 &_swigt__p_wxMenuBar,
22678 &_swigt__p_wxMenuEvent,
22679 &_swigt__p_wxMenuItem,
22680 &_swigt__p_wxMessageDialog,
22681 &_swigt__p_wxMiniFrame,
22682 &_swigt__p_wxMouseCaptureChangedEvent,
22683 &_swigt__p_wxMouseCaptureLostEvent,
22684 &_swigt__p_wxMouseEvent,
22685 &_swigt__p_wxMoveEvent,
22686 &_swigt__p_wxMultiChoiceDialog,
22687 &_swigt__p_wxNavigationKeyEvent,
22688 &_swigt__p_wxNcPaintEvent,
22689 &_swigt__p_wxNotifyEvent,
22690 &_swigt__p_wxNumberEntryDialog,
22691 &_swigt__p_wxObject,
22692 &_swigt__p_wxPCXHandler,
22693 &_swigt__p_wxPNGHandler,
22694 &_swigt__p_wxPNMHandler,
22695 &_swigt__p_wxPageSetupDialog,
22696 &_swigt__p_wxPageSetupDialogData,
22697 &_swigt__p_wxPaintEvent,
22698 &_swigt__p_wxPaletteChangedEvent,
22699 &_swigt__p_wxPanel,
22700 &_swigt__p_wxPaperSize,
22701 &_swigt__p_wxPasswordEntryDialog,
22702 &_swigt__p_wxPen,
22703 &_swigt__p_wxPoint,
22704 &_swigt__p_wxPopupWindow,
22705 &_swigt__p_wxPreviewCanvas,
22706 &_swigt__p_wxPreviewControlBar,
22707 &_swigt__p_wxPreviewFrame,
22708 &_swigt__p_wxPrintData,
22709 &_swigt__p_wxPrintDialog,
22710 &_swigt__p_wxPrintDialogData,
22711 &_swigt__p_wxPrintPreview,
22712 &_swigt__p_wxPrinter,
22713 &_swigt__p_wxProgressDialog,
22714 &_swigt__p_wxPyApp,
22715 &_swigt__p_wxPyCommandEvent,
22716 &_swigt__p_wxPyEvent,
22717 &_swigt__p_wxPyGridCellAttrProvider,
22718 &_swigt__p_wxPyGridCellEditor,
22719 &_swigt__p_wxPyGridCellRenderer,
22720 &_swigt__p_wxPyGridTableBase,
22721 &_swigt__p_wxPyHScrolledWindow,
22722 &_swigt__p_wxPyHVScrolledWindow,
22723 &_swigt__p_wxPyHtmlListBox,
22724 &_swigt__p_wxPyImageHandler,
22725 &_swigt__p_wxPyPanel,
22726 &_swigt__p_wxPyPopupTransientWindow,
22727 &_swigt__p_wxPyPreviewControlBar,
22728 &_swigt__p_wxPyPreviewFrame,
22729 &_swigt__p_wxPyPrintPreview,
22730 &_swigt__p_wxPyPrintout,
22731 &_swigt__p_wxPyScrolledWindow,
22732 &_swigt__p_wxPySizer,
22733 &_swigt__p_wxPyTaskBarIcon,
22734 &_swigt__p_wxPyVListBox,
22735 &_swigt__p_wxPyVScrolledWindow,
22736 &_swigt__p_wxPyValidator,
22737 &_swigt__p_wxPyWindow,
22738 &_swigt__p_wxQueryLayoutInfoEvent,
22739 &_swigt__p_wxQueryNewPaletteEvent,
22740 &_swigt__p_wxRect,
22741 &_swigt__p_wxSashEvent,
22742 &_swigt__p_wxSashLayoutWindow,
22743 &_swigt__p_wxSashWindow,
22744 &_swigt__p_wxScrollEvent,
22745 &_swigt__p_wxScrollWinEvent,
22746 &_swigt__p_wxScrolledWindow,
22747 &_swigt__p_wxSetCursorEvent,
22748 &_swigt__p_wxShowEvent,
22749 &_swigt__p_wxSimpleHtmlListBox,
22750 &_swigt__p_wxSingleChoiceDialog,
22751 &_swigt__p_wxSize,
22752 &_swigt__p_wxSizeEvent,
22753 &_swigt__p_wxSizer,
22754 &_swigt__p_wxSizerItem,
22755 &_swigt__p_wxSplashScreen,
22756 &_swigt__p_wxSplashScreenWindow,
22757 &_swigt__p_wxSplitterEvent,
22758 &_swigt__p_wxSplitterWindow,
22759 &_swigt__p_wxStaticBoxSizer,
22760 &_swigt__p_wxStatusBar,
22761 &_swigt__p_wxStdDialogButtonSizer,
22762 &_swigt__p_wxString,
22763 &_swigt__p_wxSysColourChangedEvent,
22764 &_swigt__p_wxTGAHandler,
22765 &_swigt__p_wxTIFFHandler,
22766 &_swigt__p_wxTaskBarIconEvent,
22767 &_swigt__p_wxTextEntryDialog,
22768 &_swigt__p_wxTipWindow,
22769 &_swigt__p_wxTopLevelWindow,
22770 &_swigt__p_wxUpdateUIEvent,
22771 &_swigt__p_wxValidator,
22772 &_swigt__p_wxVisualAttributes,
22773 &_swigt__p_wxWindow,
22774 &_swigt__p_wxWindowCreateEvent,
22775 &_swigt__p_wxWindowDestroyEvent,
22776 &_swigt__p_wxXPMHandler,
22777 };
22778
22779 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22780 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22781 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22782 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22783 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22784 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22785 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22786 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22787 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22788 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22789 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22790 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22791 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22792 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22793 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22794 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22795 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22796 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22797 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22798 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22799 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22800 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}};
22801 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22802 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}};
22803 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22804 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22805 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22806 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22807 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22808 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22809 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22810 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22811 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22812 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22813 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22814 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22815 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22816 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22817 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22818 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22819 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22820 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22821 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22822 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22823 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22824 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22825 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22826 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22827 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22828 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22829 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22830 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22831 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22832 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22833 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22834 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_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_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_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_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}};
22835 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22836 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22837 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22838 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
22839 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22840 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22841 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22842 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22843 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22844 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22845 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22846 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22847 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22848 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22849 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22850 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22851 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22852 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22853 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22854 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22855 static swig_cast_info _swigc__p_wxPyHScrolledWindow[] = {{&_swigt__p_wxPyHScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22856 static swig_cast_info _swigc__p_wxPyHVScrolledWindow[] = {{&_swigt__p_wxPyHVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22857 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22858 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22859 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22860 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22861 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22862 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22863 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22864 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22865 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22866 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22867 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22868 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22869 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22870 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22871 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22872 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22873 static swig_cast_info _swigc__p_wxSimpleHtmlListBox[] = {{&_swigt__p_wxSimpleHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22874 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22875 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22876 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22877 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22878 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22879 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22880 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22881 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22882 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22883 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22884 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_wxEventBlocker, _p_wxEventBlockerTo_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_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_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_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_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_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHScrolledWindow, _p_wxPyHScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHVScrolledWindow, _p_wxPyHVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_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_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_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}};
22885 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22886 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22887 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22888 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}};
22889 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22890 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22891 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22892 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22893 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}};
22894 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22895 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22896 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}};
22897 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22898 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22899 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22900 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22901 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22902 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22903 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}};
22904 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}};
22905 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}};
22906 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}};
22907 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22908 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22909 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22910 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22911 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22912 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}};
22913 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22914 static swig_cast_info _swigc__p_wxGridUpdateLocker[] = { {&_swigt__p_wxGridUpdateLocker, 0, 0, 0},{0, 0, 0, 0}};
22915 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22916 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}};
22917 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22918 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22919 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22920 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22921 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22922 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22923 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22924 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22925 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22926 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22927 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22928 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22929 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22930 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22931 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22932 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22933 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22934 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22935 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22936 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22937 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22938 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22939 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22940 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22941 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22942 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22943 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22944 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22945 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22946 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22947 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22948 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22949 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
22950 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22951 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22952 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22953 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22954 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22955 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22956 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22957 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22958 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22959 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22960 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22961 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_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_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_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_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_wxGIFHandler, _p_wxGIFHandlerTo_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_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_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_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHVScrolledWindow, _p_wxPyHVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHScrolledWindow, _p_wxPyHScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_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_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_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}};
22962 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHScrolledWindow, _p_wxPyHScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHVScrolledWindow, _p_wxPyHVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPanel, 0, 0, 0},{0, 0, 0, 0}};
22963 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22964 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22965 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22966 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22967 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22968 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22969 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22970 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22971 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}};
22972 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22973 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22974 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22975 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_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_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_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_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHScrolledWindow, _p_wxPyHScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHVScrolledWindow, _p_wxPyHVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 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_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_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}};
22976
22977 static swig_cast_info *swig_cast_initial[] = {
22978 _swigc__p_char,
22979 _swigc__p_form_ops_t,
22980 _swigc__p_int,
22981 _swigc__p_long,
22982 _swigc__p_unsigned_char,
22983 _swigc__p_unsigned_int,
22984 _swigc__p_unsigned_long,
22985 _swigc__p_wxANIHandler,
22986 _swigc__p_wxAcceleratorTable,
22987 _swigc__p_wxActivateEvent,
22988 _swigc__p_wxArrayString,
22989 _swigc__p_wxBMPHandler,
22990 _swigc__p_wxBoxSizer,
22991 _swigc__p_wxCURHandler,
22992 _swigc__p_wxCalculateLayoutEvent,
22993 _swigc__p_wxChildFocusEvent,
22994 _swigc__p_wxClipboardTextEvent,
22995 _swigc__p_wxCloseEvent,
22996 _swigc__p_wxColour,
22997 _swigc__p_wxColourData,
22998 _swigc__p_wxColourDialog,
22999 _swigc__p_wxCommandEvent,
23000 _swigc__p_wxContextMenuEvent,
23001 _swigc__p_wxControl,
23002 _swigc__p_wxControlWithItems,
23003 _swigc__p_wxDC,
23004 _swigc__p_wxDateEvent,
23005 _swigc__p_wxDialog,
23006 _swigc__p_wxDirDialog,
23007 _swigc__p_wxDisplayChangedEvent,
23008 _swigc__p_wxDropFilesEvent,
23009 _swigc__p_wxDuplexMode,
23010 _swigc__p_wxEraseEvent,
23011 _swigc__p_wxEvent,
23012 _swigc__p_wxEventBlocker,
23013 _swigc__p_wxEvtHandler,
23014 _swigc__p_wxFSFile,
23015 _swigc__p_wxFileDialog,
23016 _swigc__p_wxFileSystem,
23017 _swigc__p_wxFindDialogEvent,
23018 _swigc__p_wxFindReplaceData,
23019 _swigc__p_wxFindReplaceDialog,
23020 _swigc__p_wxFlexGridSizer,
23021 _swigc__p_wxFocusEvent,
23022 _swigc__p_wxFont,
23023 _swigc__p_wxFontData,
23024 _swigc__p_wxFontDialog,
23025 _swigc__p_wxFrame,
23026 _swigc__p_wxGBSizerItem,
23027 _swigc__p_wxGIFHandler,
23028 _swigc__p_wxGrid,
23029 _swigc__p_wxGridBagSizer,
23030 _swigc__p_wxGridCellAttr,
23031 _swigc__p_wxGridCellAttrProvider,
23032 _swigc__p_wxGridCellAutoWrapStringEditor,
23033 _swigc__p_wxGridCellAutoWrapStringRenderer,
23034 _swigc__p_wxGridCellBoolEditor,
23035 _swigc__p_wxGridCellBoolRenderer,
23036 _swigc__p_wxGridCellChoiceEditor,
23037 _swigc__p_wxGridCellCoords,
23038 _swigc__p_wxGridCellDateTimeRenderer,
23039 _swigc__p_wxGridCellEditor,
23040 _swigc__p_wxGridCellEnumEditor,
23041 _swigc__p_wxGridCellEnumRenderer,
23042 _swigc__p_wxGridCellFloatEditor,
23043 _swigc__p_wxGridCellFloatRenderer,
23044 _swigc__p_wxGridCellNumberEditor,
23045 _swigc__p_wxGridCellNumberRenderer,
23046 _swigc__p_wxGridCellRenderer,
23047 _swigc__p_wxGridCellStringRenderer,
23048 _swigc__p_wxGridCellTextEditor,
23049 _swigc__p_wxGridCellWorker,
23050 _swigc__p_wxGridEditorCreatedEvent,
23051 _swigc__p_wxGridEvent,
23052 _swigc__p_wxGridRangeSelectEvent,
23053 _swigc__p_wxGridSizeEvent,
23054 _swigc__p_wxGridSizer,
23055 _swigc__p_wxGridStringTable,
23056 _swigc__p_wxGridTableBase,
23057 _swigc__p_wxGridTableMessage,
23058 _swigc__p_wxGridUpdateLocker,
23059 _swigc__p_wxICOHandler,
23060 _swigc__p_wxIconizeEvent,
23061 _swigc__p_wxIdleEvent,
23062 _swigc__p_wxImage,
23063 _swigc__p_wxImageHandler,
23064 _swigc__p_wxIndividualLayoutConstraint,
23065 _swigc__p_wxInitDialogEvent,
23066 _swigc__p_wxJPEGHandler,
23067 _swigc__p_wxKeyEvent,
23068 _swigc__p_wxLayoutAlgorithm,
23069 _swigc__p_wxLayoutConstraints,
23070 _swigc__p_wxMDIChildFrame,
23071 _swigc__p_wxMDIClientWindow,
23072 _swigc__p_wxMDIParentFrame,
23073 _swigc__p_wxMaximizeEvent,
23074 _swigc__p_wxMenu,
23075 _swigc__p_wxMenuBar,
23076 _swigc__p_wxMenuEvent,
23077 _swigc__p_wxMenuItem,
23078 _swigc__p_wxMessageDialog,
23079 _swigc__p_wxMiniFrame,
23080 _swigc__p_wxMouseCaptureChangedEvent,
23081 _swigc__p_wxMouseCaptureLostEvent,
23082 _swigc__p_wxMouseEvent,
23083 _swigc__p_wxMoveEvent,
23084 _swigc__p_wxMultiChoiceDialog,
23085 _swigc__p_wxNavigationKeyEvent,
23086 _swigc__p_wxNcPaintEvent,
23087 _swigc__p_wxNotifyEvent,
23088 _swigc__p_wxNumberEntryDialog,
23089 _swigc__p_wxObject,
23090 _swigc__p_wxPCXHandler,
23091 _swigc__p_wxPNGHandler,
23092 _swigc__p_wxPNMHandler,
23093 _swigc__p_wxPageSetupDialog,
23094 _swigc__p_wxPageSetupDialogData,
23095 _swigc__p_wxPaintEvent,
23096 _swigc__p_wxPaletteChangedEvent,
23097 _swigc__p_wxPanel,
23098 _swigc__p_wxPaperSize,
23099 _swigc__p_wxPasswordEntryDialog,
23100 _swigc__p_wxPen,
23101 _swigc__p_wxPoint,
23102 _swigc__p_wxPopupWindow,
23103 _swigc__p_wxPreviewCanvas,
23104 _swigc__p_wxPreviewControlBar,
23105 _swigc__p_wxPreviewFrame,
23106 _swigc__p_wxPrintData,
23107 _swigc__p_wxPrintDialog,
23108 _swigc__p_wxPrintDialogData,
23109 _swigc__p_wxPrintPreview,
23110 _swigc__p_wxPrinter,
23111 _swigc__p_wxProgressDialog,
23112 _swigc__p_wxPyApp,
23113 _swigc__p_wxPyCommandEvent,
23114 _swigc__p_wxPyEvent,
23115 _swigc__p_wxPyGridCellAttrProvider,
23116 _swigc__p_wxPyGridCellEditor,
23117 _swigc__p_wxPyGridCellRenderer,
23118 _swigc__p_wxPyGridTableBase,
23119 _swigc__p_wxPyHScrolledWindow,
23120 _swigc__p_wxPyHVScrolledWindow,
23121 _swigc__p_wxPyHtmlListBox,
23122 _swigc__p_wxPyImageHandler,
23123 _swigc__p_wxPyPanel,
23124 _swigc__p_wxPyPopupTransientWindow,
23125 _swigc__p_wxPyPreviewControlBar,
23126 _swigc__p_wxPyPreviewFrame,
23127 _swigc__p_wxPyPrintPreview,
23128 _swigc__p_wxPyPrintout,
23129 _swigc__p_wxPyScrolledWindow,
23130 _swigc__p_wxPySizer,
23131 _swigc__p_wxPyTaskBarIcon,
23132 _swigc__p_wxPyVListBox,
23133 _swigc__p_wxPyVScrolledWindow,
23134 _swigc__p_wxPyValidator,
23135 _swigc__p_wxPyWindow,
23136 _swigc__p_wxQueryLayoutInfoEvent,
23137 _swigc__p_wxQueryNewPaletteEvent,
23138 _swigc__p_wxRect,
23139 _swigc__p_wxSashEvent,
23140 _swigc__p_wxSashLayoutWindow,
23141 _swigc__p_wxSashWindow,
23142 _swigc__p_wxScrollEvent,
23143 _swigc__p_wxScrollWinEvent,
23144 _swigc__p_wxScrolledWindow,
23145 _swigc__p_wxSetCursorEvent,
23146 _swigc__p_wxShowEvent,
23147 _swigc__p_wxSimpleHtmlListBox,
23148 _swigc__p_wxSingleChoiceDialog,
23149 _swigc__p_wxSize,
23150 _swigc__p_wxSizeEvent,
23151 _swigc__p_wxSizer,
23152 _swigc__p_wxSizerItem,
23153 _swigc__p_wxSplashScreen,
23154 _swigc__p_wxSplashScreenWindow,
23155 _swigc__p_wxSplitterEvent,
23156 _swigc__p_wxSplitterWindow,
23157 _swigc__p_wxStaticBoxSizer,
23158 _swigc__p_wxStatusBar,
23159 _swigc__p_wxStdDialogButtonSizer,
23160 _swigc__p_wxString,
23161 _swigc__p_wxSysColourChangedEvent,
23162 _swigc__p_wxTGAHandler,
23163 _swigc__p_wxTIFFHandler,
23164 _swigc__p_wxTaskBarIconEvent,
23165 _swigc__p_wxTextEntryDialog,
23166 _swigc__p_wxTipWindow,
23167 _swigc__p_wxTopLevelWindow,
23168 _swigc__p_wxUpdateUIEvent,
23169 _swigc__p_wxValidator,
23170 _swigc__p_wxVisualAttributes,
23171 _swigc__p_wxWindow,
23172 _swigc__p_wxWindowCreateEvent,
23173 _swigc__p_wxWindowDestroyEvent,
23174 _swigc__p_wxXPMHandler,
23175 };
23176
23177
23178 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23179
23180 static swig_const_info swig_const_table[] = {
23181 {0, 0, 0, 0.0, 0, 0}};
23182
23183 #ifdef __cplusplus
23184 }
23185 #endif
23186 /* -----------------------------------------------------------------------------
23187 * Type initialization:
23188 * This problem is tough by the requirement that no dynamic
23189 * memory is used. Also, since swig_type_info structures store pointers to
23190 * swig_cast_info structures and swig_cast_info structures store pointers back
23191 * to swig_type_info structures, we need some lookup code at initialization.
23192 * The idea is that swig generates all the structures that are needed.
23193 * The runtime then collects these partially filled structures.
23194 * The SWIG_InitializeModule function takes these initial arrays out of
23195 * swig_module, and does all the lookup, filling in the swig_module.types
23196 * array with the correct data and linking the correct swig_cast_info
23197 * structures together.
23198 *
23199 * The generated swig_type_info structures are assigned staticly to an initial
23200 * array. We just loop though that array, and handle each type individually.
23201 * First we lookup if this type has been already loaded, and if so, use the
23202 * loaded structure instead of the generated one. Then we have to fill in the
23203 * cast linked list. The cast data is initially stored in something like a
23204 * two-dimensional array. Each row corresponds to a type (there are the same
23205 * number of rows as there are in the swig_type_initial array). Each entry in
23206 * a column is one of the swig_cast_info structures for that type.
23207 * The cast_initial array is actually an array of arrays, because each row has
23208 * a variable number of columns. So to actually build the cast linked list,
23209 * we find the array of casts associated with the type, and loop through it
23210 * adding the casts to the list. The one last trick we need to do is making
23211 * sure the type pointer in the swig_cast_info struct is correct.
23212 *
23213 * First off, we lookup the cast->type name to see if it is already loaded.
23214 * There are three cases to handle:
23215 * 1) If the cast->type has already been loaded AND the type we are adding
23216 * casting info to has not been loaded (it is in this module), THEN we
23217 * replace the cast->type pointer with the type pointer that has already
23218 * been loaded.
23219 * 2) If BOTH types (the one we are adding casting info to, and the
23220 * cast->type) are loaded, THEN the cast info has already been loaded by
23221 * the previous module so we just ignore it.
23222 * 3) Finally, if cast->type has not already been loaded, then we add that
23223 * swig_cast_info to the linked list (because the cast->type) pointer will
23224 * be correct.
23225 * ----------------------------------------------------------------------------- */
23226
23227 #ifdef __cplusplus
23228 extern "C" {
23229 #if 0
23230 } /* c-mode */
23231 #endif
23232 #endif
23233
23234 #if 0
23235 #define SWIGRUNTIME_DEBUG
23236 #endif
23237
23238 SWIGRUNTIME void
23239 SWIG_InitializeModule(void *clientdata) {
23240 size_t i;
23241 swig_module_info *module_head;
23242 static int init_run = 0;
23243
23244 clientdata = clientdata;
23245
23246 if (init_run) return;
23247 init_run = 1;
23248
23249 /* Initialize the swig_module */
23250 swig_module.type_initial = swig_type_initial;
23251 swig_module.cast_initial = swig_cast_initial;
23252
23253 /* Try and load any already created modules */
23254 module_head = SWIG_GetModule(clientdata);
23255 if (module_head) {
23256 swig_module.next = module_head->next;
23257 module_head->next = &swig_module;
23258 } else {
23259 /* This is the first module loaded */
23260 swig_module.next = &swig_module;
23261 SWIG_SetModule(clientdata, &swig_module);
23262 }
23263
23264 /* Now work on filling in swig_module.types */
23265 #ifdef SWIGRUNTIME_DEBUG
23266 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23267 #endif
23268 for (i = 0; i < swig_module.size; ++i) {
23269 swig_type_info *type = 0;
23270 swig_type_info *ret;
23271 swig_cast_info *cast;
23272
23273 #ifdef SWIGRUNTIME_DEBUG
23274 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23275 #endif
23276
23277 /* if there is another module already loaded */
23278 if (swig_module.next != &swig_module) {
23279 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23280 }
23281 if (type) {
23282 /* Overwrite clientdata field */
23283 #ifdef SWIGRUNTIME_DEBUG
23284 printf("SWIG_InitializeModule: found type %s\n", type->name);
23285 #endif
23286 if (swig_module.type_initial[i]->clientdata) {
23287 type->clientdata = swig_module.type_initial[i]->clientdata;
23288 #ifdef SWIGRUNTIME_DEBUG
23289 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23290 #endif
23291 }
23292 } else {
23293 type = swig_module.type_initial[i];
23294 }
23295
23296 /* Insert casting types */
23297 cast = swig_module.cast_initial[i];
23298 while (cast->type) {
23299 /* Don't need to add information already in the list */
23300 ret = 0;
23301 #ifdef SWIGRUNTIME_DEBUG
23302 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23303 #endif
23304 if (swig_module.next != &swig_module) {
23305 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23306 #ifdef SWIGRUNTIME_DEBUG
23307 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23308 #endif
23309 }
23310 if (ret) {
23311 if (type == swig_module.type_initial[i]) {
23312 #ifdef SWIGRUNTIME_DEBUG
23313 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23314 #endif
23315 cast->type = ret;
23316 ret = 0;
23317 } else {
23318 /* Check for casting already in the list */
23319 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23320 #ifdef SWIGRUNTIME_DEBUG
23321 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23322 #endif
23323 if (!ocast) ret = 0;
23324 }
23325 }
23326
23327 if (!ret) {
23328 #ifdef SWIGRUNTIME_DEBUG
23329 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23330 #endif
23331 if (type->cast) {
23332 type->cast->prev = cast;
23333 cast->next = type->cast;
23334 }
23335 type->cast = cast;
23336 }
23337 cast++;
23338 }
23339 /* Set entry in modules->types array equal to the type */
23340 swig_module.types[i] = type;
23341 }
23342 swig_module.types[i] = 0;
23343
23344 #ifdef SWIGRUNTIME_DEBUG
23345 printf("**** SWIG_InitializeModule: Cast List ******\n");
23346 for (i = 0; i < swig_module.size; ++i) {
23347 int j = 0;
23348 swig_cast_info *cast = swig_module.cast_initial[i];
23349 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23350 while (cast->type) {
23351 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23352 cast++;
23353 ++j;
23354 }
23355 printf("---- Total casts: %d\n",j);
23356 }
23357 printf("**** SWIG_InitializeModule: Cast List ******\n");
23358 #endif
23359 }
23360
23361 /* This function will propagate the clientdata field of type to
23362 * any new swig_type_info structures that have been added into the list
23363 * of equivalent types. It is like calling
23364 * SWIG_TypeClientData(type, clientdata) a second time.
23365 */
23366 SWIGRUNTIME void
23367 SWIG_PropagateClientData(void) {
23368 size_t i;
23369 swig_cast_info *equiv;
23370 static int init_run = 0;
23371
23372 if (init_run) return;
23373 init_run = 1;
23374
23375 for (i = 0; i < swig_module.size; i++) {
23376 if (swig_module.types[i]->clientdata) {
23377 equiv = swig_module.types[i]->cast;
23378 while (equiv) {
23379 if (!equiv->converter) {
23380 if (equiv->type && !equiv->type->clientdata)
23381 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23382 }
23383 equiv = equiv->next;
23384 }
23385 }
23386 }
23387 }
23388
23389 #ifdef __cplusplus
23390 #if 0
23391 {
23392 /* c-mode */
23393 #endif
23394 }
23395 #endif
23396
23397
23398
23399 #ifdef __cplusplus
23400 extern "C" {
23401 #endif
23402
23403 /* Python-specific SWIG API */
23404 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23405 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23406 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23407
23408 /* -----------------------------------------------------------------------------
23409 * global variable support code.
23410 * ----------------------------------------------------------------------------- */
23411
23412 typedef struct swig_globalvar {
23413 char *name; /* Name of global variable */
23414 PyObject *(*get_attr)(void); /* Return the current value */
23415 int (*set_attr)(PyObject *); /* Set the value */
23416 struct swig_globalvar *next;
23417 } swig_globalvar;
23418
23419 typedef struct swig_varlinkobject {
23420 PyObject_HEAD
23421 swig_globalvar *vars;
23422 } swig_varlinkobject;
23423
23424 SWIGINTERN PyObject *
23425 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23426 return PyString_FromString("<Swig global variables>");
23427 }
23428
23429 SWIGINTERN PyObject *
23430 swig_varlink_str(swig_varlinkobject *v) {
23431 PyObject *str = PyString_FromString("(");
23432 swig_globalvar *var;
23433 for (var = v->vars; var; var=var->next) {
23434 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23435 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23436 }
23437 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23438 return str;
23439 }
23440
23441 SWIGINTERN int
23442 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23443 PyObject *str = swig_varlink_str(v);
23444 fprintf(fp,"Swig global variables ");
23445 fprintf(fp,"%s\n", PyString_AsString(str));
23446 Py_DECREF(str);
23447 return 0;
23448 }
23449
23450 SWIGINTERN void
23451 swig_varlink_dealloc(swig_varlinkobject *v) {
23452 swig_globalvar *var = v->vars;
23453 while (var) {
23454 swig_globalvar *n = var->next;
23455 free(var->name);
23456 free(var);
23457 var = n;
23458 }
23459 }
23460
23461 SWIGINTERN PyObject *
23462 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23463 PyObject *res = NULL;
23464 swig_globalvar *var = v->vars;
23465 while (var) {
23466 if (strcmp(var->name,n) == 0) {
23467 res = (*var->get_attr)();
23468 break;
23469 }
23470 var = var->next;
23471 }
23472 if (res == NULL && !PyErr_Occurred()) {
23473 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23474 }
23475 return res;
23476 }
23477
23478 SWIGINTERN int
23479 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23480 int res = 1;
23481 swig_globalvar *var = v->vars;
23482 while (var) {
23483 if (strcmp(var->name,n) == 0) {
23484 res = (*var->set_attr)(p);
23485 break;
23486 }
23487 var = var->next;
23488 }
23489 if (res == 1 && !PyErr_Occurred()) {
23490 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23491 }
23492 return res;
23493 }
23494
23495 SWIGINTERN PyTypeObject*
23496 swig_varlink_type(void) {
23497 static char varlink__doc__[] = "Swig var link object";
23498 static PyTypeObject varlink_type;
23499 static int type_init = 0;
23500 if (!type_init) {
23501 const PyTypeObject tmp
23502 = {
23503 PyObject_HEAD_INIT(NULL)
23504 0, /* Number of items in variable part (ob_size) */
23505 (char *)"swigvarlink", /* Type name (tp_name) */
23506 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23507 0, /* Itemsize (tp_itemsize) */
23508 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23509 (printfunc) swig_varlink_print, /* Print (tp_print) */
23510 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23511 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23512 0, /* tp_compare */
23513 (reprfunc) swig_varlink_repr, /* tp_repr */
23514 0, /* tp_as_number */
23515 0, /* tp_as_sequence */
23516 0, /* tp_as_mapping */
23517 0, /* tp_hash */
23518 0, /* tp_call */
23519 (reprfunc)swig_varlink_str, /* tp_str */
23520 0, /* tp_getattro */
23521 0, /* tp_setattro */
23522 0, /* tp_as_buffer */
23523 0, /* tp_flags */
23524 varlink__doc__, /* tp_doc */
23525 0, /* tp_traverse */
23526 0, /* tp_clear */
23527 0, /* tp_richcompare */
23528 0, /* tp_weaklistoffset */
23529 #if PY_VERSION_HEX >= 0x02020000
23530 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23531 #endif
23532 #if PY_VERSION_HEX >= 0x02030000
23533 0, /* tp_del */
23534 #endif
23535 #ifdef COUNT_ALLOCS
23536 0,0,0,0 /* tp_alloc -> tp_next */
23537 #endif
23538 };
23539 varlink_type = tmp;
23540 varlink_type.ob_type = &PyType_Type;
23541 type_init = 1;
23542 }
23543 return &varlink_type;
23544 }
23545
23546 /* Create a variable linking object for use later */
23547 SWIGINTERN PyObject *
23548 SWIG_Python_newvarlink(void) {
23549 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23550 if (result) {
23551 result->vars = 0;
23552 }
23553 return ((PyObject*) result);
23554 }
23555
23556 SWIGINTERN void
23557 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23558 swig_varlinkobject *v = (swig_varlinkobject *) p;
23559 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23560 if (gv) {
23561 size_t size = strlen(name)+1;
23562 gv->name = (char *)malloc(size);
23563 if (gv->name) {
23564 strncpy(gv->name,name,size);
23565 gv->get_attr = get_attr;
23566 gv->set_attr = set_attr;
23567 gv->next = v->vars;
23568 }
23569 }
23570 v->vars = gv;
23571 }
23572
23573 SWIGINTERN PyObject *
23574 SWIG_globals() {
23575 static PyObject *_SWIG_globals = 0;
23576 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23577 return _SWIG_globals;
23578 }
23579
23580 /* -----------------------------------------------------------------------------
23581 * constants/methods manipulation
23582 * ----------------------------------------------------------------------------- */
23583
23584 /* Install Constants */
23585 SWIGINTERN void
23586 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23587 PyObject *obj = 0;
23588 size_t i;
23589 for (i = 0; constants[i].type; ++i) {
23590 switch(constants[i].type) {
23591 case SWIG_PY_POINTER:
23592 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23593 break;
23594 case SWIG_PY_BINARY:
23595 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23596 break;
23597 default:
23598 obj = 0;
23599 break;
23600 }
23601 if (obj) {
23602 PyDict_SetItemString(d, constants[i].name, obj);
23603 Py_DECREF(obj);
23604 }
23605 }
23606 }
23607
23608 /* -----------------------------------------------------------------------------*/
23609 /* Fix SwigMethods to carry the callback ptrs when needed */
23610 /* -----------------------------------------------------------------------------*/
23611
23612 SWIGINTERN void
23613 SWIG_Python_FixMethods(PyMethodDef *methods,
23614 swig_const_info *const_table,
23615 swig_type_info **types,
23616 swig_type_info **types_initial) {
23617 size_t i;
23618 for (i = 0; methods[i].ml_name; ++i) {
23619 const char *c = methods[i].ml_doc;
23620 if (c && (c = strstr(c, "swig_ptr: "))) {
23621 int j;
23622 swig_const_info *ci = 0;
23623 const char *name = c + 10;
23624 for (j = 0; const_table[j].type; ++j) {
23625 if (strncmp(const_table[j].name, name,
23626 strlen(const_table[j].name)) == 0) {
23627 ci = &(const_table[j]);
23628 break;
23629 }
23630 }
23631 if (ci) {
23632 size_t shift = (ci->ptype) - types;
23633 swig_type_info *ty = types_initial[shift];
23634 size_t ldoc = (c - methods[i].ml_doc);
23635 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23636 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23637 if (ndoc) {
23638 char *buff = ndoc;
23639 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23640 if (ptr) {
23641 strncpy(buff, methods[i].ml_doc, ldoc);
23642 buff += ldoc;
23643 strncpy(buff, "swig_ptr: ", 10);
23644 buff += 10;
23645 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23646 methods[i].ml_doc = ndoc;
23647 }
23648 }
23649 }
23650 }
23651 }
23652 }
23653
23654 #ifdef __cplusplus
23655 }
23656 #endif
23657
23658 /* -----------------------------------------------------------------------------*
23659 * Partial Init method
23660 * -----------------------------------------------------------------------------*/
23661
23662 #ifdef __cplusplus
23663 extern "C"
23664 #endif
23665 SWIGEXPORT void SWIG_init(void) {
23666 PyObject *m, *d;
23667
23668 /* Fix SwigMethods to carry the callback ptrs when needed */
23669 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23670
23671 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23672 d = PyModule_GetDict(m);
23673
23674 SWIG_InitializeModule(0);
23675 SWIG_InstallConstants(d,swig_const_table);
23676
23677
23678 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23679 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23680 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23681 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23682 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23683 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23684 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23685 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23686 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23687 SWIG_Python_SetConstant(d, "GRID_AUTOSIZE",SWIG_From_int(static_cast< int >(wxGRID_AUTOSIZE)));
23688 SWIG_Python_SetConstant(d, "GRID_COLUMN",SWIG_From_int(static_cast< int >(wxGRID_COLUMN)));
23689 SWIG_Python_SetConstant(d, "GRID_ROW",SWIG_From_int(static_cast< int >(wxGRID_ROW)));
23690 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23691 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23692 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23693 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23694 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23695 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23696 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23697 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23698 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23699 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23700 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23701 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23702 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23703 SWIG_addvarlink(SWIG_globals(),(char*)"OneString",OneString_get, OneString_set);
23704 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23705 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23706 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23707 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23708 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23709 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23710 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23711 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23712 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23713 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23714 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23715 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23716 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23717 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23718 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23719 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23720 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23721 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23722 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23723 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23724 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23725 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23726 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23727 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23728 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23729 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23730 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23731 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23732 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23733 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23734 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23735 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23736 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23737 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23738
23739
23740 }
23741
wxWidgets (Impactor)