]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
removed code inside USE_SIZABLE_CALENDAR, we should allow making the main calendar...
[wxWidgets.git] / wxPython / src / mac / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_long swig_types[3]
2470 #define SWIGTYPE_p_unsigned_char swig_types[4]
2471 #define SWIGTYPE_p_unsigned_int swig_types[5]
2472 #define SWIGTYPE_p_unsigned_long swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2481 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2482 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2484 #define SWIGTYPE_p_wxColour swig_types[18]
2485 #define SWIGTYPE_p_wxColourData swig_types[19]
2486 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2488 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2489 #define SWIGTYPE_p_wxControl swig_types[23]
2490 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2491 #define SWIGTYPE_p_wxDC swig_types[25]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDialog swig_types[27]
2494 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2495 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2496 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2498 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2499 #define SWIGTYPE_p_wxEvent swig_types[33]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[34]
2501 #define SWIGTYPE_p_wxFSFile swig_types[35]
2502 #define SWIGTYPE_p_wxFileDialog swig_types[36]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[37]
2504 #define SWIGTYPE_p_wxFindDialogEvent swig_types[38]
2505 #define SWIGTYPE_p_wxFindReplaceData swig_types[39]
2506 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[40]
2507 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2508 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2509 #define SWIGTYPE_p_wxFont swig_types[43]
2510 #define SWIGTYPE_p_wxFontData swig_types[44]
2511 #define SWIGTYPE_p_wxFontDialog swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2514 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2515 #define SWIGTYPE_p_wxGrid swig_types[49]
2516 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2517 #define SWIGTYPE_p_wxGridCellAttr swig_types[51]
2518 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[52]
2519 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[53]
2520 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[54]
2521 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[55]
2522 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[56]
2523 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[57]
2524 #define SWIGTYPE_p_wxGridCellCoords swig_types[58]
2525 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[59]
2526 #define SWIGTYPE_p_wxGridCellEditor swig_types[60]
2527 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[61]
2528 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[62]
2529 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[63]
2530 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[64]
2531 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[65]
2532 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[66]
2533 #define SWIGTYPE_p_wxGridCellRenderer swig_types[67]
2534 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[68]
2535 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[69]
2536 #define SWIGTYPE_p_wxGridCellWorker swig_types[70]
2537 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[71]
2538 #define SWIGTYPE_p_wxGridEvent swig_types[72]
2539 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[73]
2540 #define SWIGTYPE_p_wxGridSizeEvent swig_types[74]
2541 #define SWIGTYPE_p_wxGridSizer swig_types[75]
2542 #define SWIGTYPE_p_wxGridStringTable swig_types[76]
2543 #define SWIGTYPE_p_wxGridTableBase swig_types[77]
2544 #define SWIGTYPE_p_wxGridTableMessage swig_types[78]
2545 #define SWIGTYPE_p_wxICOHandler swig_types[79]
2546 #define SWIGTYPE_p_wxIconizeEvent swig_types[80]
2547 #define SWIGTYPE_p_wxIdleEvent swig_types[81]
2548 #define SWIGTYPE_p_wxImage swig_types[82]
2549 #define SWIGTYPE_p_wxImageHandler swig_types[83]
2550 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[84]
2551 #define SWIGTYPE_p_wxInitDialogEvent swig_types[85]
2552 #define SWIGTYPE_p_wxJPEGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxKeyEvent swig_types[87]
2554 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[88]
2555 #define SWIGTYPE_p_wxLayoutConstraints swig_types[89]
2556 #define SWIGTYPE_p_wxMDIChildFrame swig_types[90]
2557 #define SWIGTYPE_p_wxMDIClientWindow swig_types[91]
2558 #define SWIGTYPE_p_wxMDIParentFrame swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMessageDialog swig_types[98]
2565 #define SWIGTYPE_p_wxMiniFrame swig_types[99]
2566 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMoveEvent swig_types[103]
2570 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[104]
2571 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNcPaintEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNotifyEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNumberEntryDialog swig_types[108]
2575 #define SWIGTYPE_p_wxObject swig_types[109]
2576 #define SWIGTYPE_p_wxPCXHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNGHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPNMHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPageSetupDialog swig_types[113]
2580 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[114]
2581 #define SWIGTYPE_p_wxPaintEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPanel swig_types[117]
2584 #define SWIGTYPE_p_wxPaperSize swig_types[118]
2585 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[119]
2586 #define SWIGTYPE_p_wxPen swig_types[120]
2587 #define SWIGTYPE_p_wxPoint swig_types[121]
2588 #define SWIGTYPE_p_wxPopupWindow swig_types[122]
2589 #define SWIGTYPE_p_wxPreviewCanvas swig_types[123]
2590 #define SWIGTYPE_p_wxPreviewControlBar swig_types[124]
2591 #define SWIGTYPE_p_wxPreviewFrame swig_types[125]
2592 #define SWIGTYPE_p_wxPrintData swig_types[126]
2593 #define SWIGTYPE_p_wxPrintDialog swig_types[127]
2594 #define SWIGTYPE_p_wxPrintDialogData swig_types[128]
2595 #define SWIGTYPE_p_wxPrintPreview swig_types[129]
2596 #define SWIGTYPE_p_wxPrinter swig_types[130]
2597 #define SWIGTYPE_p_wxProgressDialog swig_types[131]
2598 #define SWIGTYPE_p_wxPyApp swig_types[132]
2599 #define SWIGTYPE_p_wxPyCommandEvent swig_types[133]
2600 #define SWIGTYPE_p_wxPyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[135]
2602 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[136]
2603 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[137]
2604 #define SWIGTYPE_p_wxPyGridTableBase swig_types[138]
2605 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[139]
2606 #define SWIGTYPE_p_wxPyImageHandler swig_types[140]
2607 #define SWIGTYPE_p_wxPyPanel swig_types[141]
2608 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[142]
2609 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[143]
2610 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[144]
2611 #define SWIGTYPE_p_wxPyPrintPreview swig_types[145]
2612 #define SWIGTYPE_p_wxPyPrintout swig_types[146]
2613 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[147]
2614 #define SWIGTYPE_p_wxPySizer swig_types[148]
2615 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[149]
2616 #define SWIGTYPE_p_wxPyVListBox swig_types[150]
2617 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[151]
2618 #define SWIGTYPE_p_wxPyValidator swig_types[152]
2619 #define SWIGTYPE_p_wxPyWindow swig_types[153]
2620 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[154]
2621 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[155]
2622 #define SWIGTYPE_p_wxRect swig_types[156]
2623 #define SWIGTYPE_p_wxSashEvent swig_types[157]
2624 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[158]
2625 #define SWIGTYPE_p_wxSashWindow swig_types[159]
2626 #define SWIGTYPE_p_wxScrollEvent swig_types[160]
2627 #define SWIGTYPE_p_wxScrollWinEvent swig_types[161]
2628 #define SWIGTYPE_p_wxScrolledWindow swig_types[162]
2629 #define SWIGTYPE_p_wxSetCursorEvent swig_types[163]
2630 #define SWIGTYPE_p_wxShowEvent swig_types[164]
2631 #define SWIGTYPE_p_wxSimpleHtmlListBox swig_types[165]
2632 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[166]
2633 #define SWIGTYPE_p_wxSize swig_types[167]
2634 #define SWIGTYPE_p_wxSizeEvent swig_types[168]
2635 #define SWIGTYPE_p_wxSizer swig_types[169]
2636 #define SWIGTYPE_p_wxSizerItem swig_types[170]
2637 #define SWIGTYPE_p_wxSplashScreen swig_types[171]
2638 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[172]
2639 #define SWIGTYPE_p_wxSplitterEvent swig_types[173]
2640 #define SWIGTYPE_p_wxSplitterWindow swig_types[174]
2641 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[175]
2642 #define SWIGTYPE_p_wxStatusBar swig_types[176]
2643 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[177]
2644 #define SWIGTYPE_p_wxString swig_types[178]
2645 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[179]
2646 #define SWIGTYPE_p_wxTGAHandler swig_types[180]
2647 #define SWIGTYPE_p_wxTIFFHandler swig_types[181]
2648 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[182]
2649 #define SWIGTYPE_p_wxTextEntryDialog swig_types[183]
2650 #define SWIGTYPE_p_wxTipWindow swig_types[184]
2651 #define SWIGTYPE_p_wxTopLevelWindow swig_types[185]
2652 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[186]
2653 #define SWIGTYPE_p_wxValidator swig_types[187]
2654 #define SWIGTYPE_p_wxVisualAttributes swig_types[188]
2655 #define SWIGTYPE_p_wxWindow swig_types[189]
2656 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[190]
2657 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[191]
2658 #define SWIGTYPE_p_wxXPMHandler swig_types[192]
2659 static swig_type_info *swig_types[194];
2660 static swig_module_info swig_module = {swig_types, 193, 0, 0, 0, 0};
2661 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2662 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2663
2664 /* -------- TYPES TABLE (END) -------- */
2665
2666 #if (PY_VERSION_HEX <= 0x02000000)
2667 # if !defined(SWIG_PYTHON_CLASSIC)
2668 # error "This python version requires to use swig with the '-classic' option"
2669 # endif
2670 #endif
2671 #if (PY_VERSION_HEX <= 0x02020000)
2672 # error "This python version requires to use swig with the '-nomodern' option"
2673 #endif
2674 #if (PY_VERSION_HEX <= 0x02020000)
2675 # error "This python version requires to use swig with the '-nomodernargs' option"
2676 #endif
2677 #ifndef METH_O
2678 # error "This python version requires to use swig with the '-nofastunpack' option"
2679 #endif
2680
2681 /*-----------------------------------------------
2682 @(target):= _grid.so
2683 ------------------------------------------------*/
2684 #define SWIG_init init_grid
2685
2686 #define SWIG_name "_grid"
2687
2688 #define SWIGVERSION 0x010329
2689
2690
2691 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2692 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2693
2694
2695 #include <stdexcept>
2696
2697
2698 namespace swig {
2699 class PyObject_ptr {
2700 protected:
2701 PyObject *_obj;
2702
2703 public:
2704 PyObject_ptr() :_obj(0)
2705 {
2706 }
2707
2708 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2709 {
2710 Py_XINCREF(_obj);
2711 }
2712
2713 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2714 {
2715 if (initial_ref) Py_XINCREF(_obj);
2716 }
2717
2718 PyObject_ptr & operator=(const PyObject_ptr& item)
2719 {
2720 Py_XINCREF(item._obj);
2721 Py_XDECREF(_obj);
2722 _obj = item._obj;
2723 return *this;
2724 }
2725
2726 ~PyObject_ptr()
2727 {
2728 Py_XDECREF(_obj);
2729 }
2730
2731 operator PyObject *() const
2732 {
2733 return _obj;
2734 }
2735
2736 PyObject *operator->() const
2737 {
2738 return _obj;
2739 }
2740 };
2741 }
2742
2743
2744 namespace swig {
2745 struct PyObject_var : PyObject_ptr {
2746 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2747
2748 PyObject_var & operator = (PyObject* obj)
2749 {
2750 Py_XDECREF(_obj);
2751 _obj = obj;
2752 return *this;
2753 }
2754 };
2755 }
2756
2757
2758 #include "wx/wxPython/wxPython.h"
2759 #include "wx/wxPython/pyclasses.h"
2760 #include "wx/wxPython/printfw.h"
2761
2762 #include <wx/grid.h>
2763 #include <wx/generic/gridctrl.h>
2764
2765
2766 static const wxString wxPyEmptyString(wxEmptyString);
2767 static const wxString wxPyGridNameStr(wxGridNameStr);
2768 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2769
2770
2771 #define wxPyMake_TEMPLATE(TYPE) \
2772 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2773 PyObject* target = NULL; \
2774 if (source) { \
2775 /* Check if there is already a pointer to a Python object in the \
2776 OOR data that we can use. */ \
2777 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2778 if (data) { \
2779 target = data->m_obj; \
2780 if (target) \
2781 Py_INCREF(target); \
2782 } \
2783 /* Otherwise make a new wrapper for it the old fashioned way and \
2784 give it the OOR treatment */ \
2785 if (! target) { \
2786 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2787 if (target) \
2788 source->SetClientObject(new wxPyOORClientData(target)); \
2789 } \
2790 } else { /* source was NULL so return None. */ \
2791 Py_INCREF(Py_None); target = Py_None; \
2792 } \
2793 return target; \
2794 } \
2795
2796
2797 wxPyMake_TEMPLATE(wxGridCellRenderer)
2798 wxPyMake_TEMPLATE(wxGridCellEditor)
2799 wxPyMake_TEMPLATE(wxGridCellAttr)
2800 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2801 wxPyMake_TEMPLATE(wxGridTableBase)
2802
2803
2804
2805 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2806 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2807 wxGridCellAttr* rval = NULL; \
2808 bool found; \
2809 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2810 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2811 PyObject* ro; \
2812 wxGridCellAttr* ptr; \
2813 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2814 if (ro) { \
2815 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2816 rval = ptr; \
2817 Py_DECREF(ro); \
2818 } \
2819 } \
2820 wxPyEndBlockThreads(blocked); \
2821 if (! found) \
2822 rval = PCLASS::CBNAME(a, b, c); \
2823 return rval; \
2824 }
2825
2826
2827 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2828 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2829 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2830 bool found; \
2831 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2832 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2833 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2834 Py_DECREF(obj); \
2835 } \
2836 wxPyEndBlockThreads(blocked); \
2837 if (! found) \
2838 PCLASS::CBNAME(attr, a, b); \
2839 }
2840
2841
2842
2843 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2844 void CBNAME(wxGridCellAttr *attr, int val) { \
2845 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2846 bool found; \
2847 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2848 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2849 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2850 Py_DECREF(obj); \
2851 } \
2852 wxPyEndBlockThreads(blocked); \
2853 if (! found) \
2854 PCLASS::CBNAME(attr, val); \
2855 }
2856
2857
2858
2859 #define PYCALLBACK_INT__pure(CBNAME) \
2860 int CBNAME() { \
2861 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2862 int rval = 0; \
2863 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2864 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2865 wxPyEndBlockThreads(blocked); \
2866 return rval; \
2867 }
2868
2869
2870
2871 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2872 bool CBNAME(int a, int b) { \
2873 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2874 bool rval = 0; \
2875 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2876 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2877 wxPyEndBlockThreads(blocked); \
2878 return rval; \
2879 }
2880
2881
2882 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2883 wxString CBNAME(int a, int b) { \
2884 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2885 wxString rval; \
2886 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2887 PyObject* ro; \
2888 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2889 if (ro) { \
2890 rval = Py2wxString(ro); \
2891 Py_DECREF(ro); \
2892 } \
2893 } \
2894 wxPyEndBlockThreads(blocked); \
2895 return rval; \
2896 }
2897
2898
2899 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2900 void CBNAME(int a, int b, const wxString& c) { \
2901 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2902 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2903 PyObject* s = wx2PyString(c); \
2904 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2905 Py_DECREF(s); \
2906 } \
2907 wxPyEndBlockThreads(blocked); \
2908 }
2909
2910
2911 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2912 wxString CBNAME(int a, int b) { \
2913 bool found; \
2914 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2915 wxString rval; \
2916 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2917 PyObject* ro; \
2918 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2919 if (ro) { \
2920 rval = Py2wxString(ro); \
2921 Py_DECREF(ro); \
2922 } \
2923 } \
2924 wxPyEndBlockThreads(blocked); \
2925 if (! found) \
2926 rval = PCLASS::CBNAME(a, b); \
2927 return rval; \
2928 }
2929
2930
2931 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2932 bool CBNAME(int a, int b, const wxString& c) { \
2933 bool rval = 0; \
2934 bool found; \
2935 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2936 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2937 PyObject* s = wx2PyString(c); \
2938 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2939 Py_DECREF(s); \
2940 } \
2941 wxPyEndBlockThreads(blocked); \
2942 if (! found) \
2943 rval = PCLASS::CBNAME(a,b,c); \
2944 return rval; \
2945 }
2946
2947
2948
2949
2950 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2951 long CBNAME(int a, int b) { \
2952 long rval; \
2953 bool found; \
2954 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2955 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2956 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2957 wxPyEndBlockThreads(blocked); \
2958 if (! found) \
2959 rval = PCLASS::CBNAME(a,b); \
2960 return rval; \
2961 }
2962
2963
2964 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2965 bool CBNAME(int a, int b) { \
2966 bool rval = 0; \
2967 bool found; \
2968 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2969 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2970 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2971 wxPyEndBlockThreads(blocked); \
2972 if (! found) \
2973 rval = PCLASS::CBNAME(a,b); \
2974 return rval; \
2975 }
2976
2977
2978
2979 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2980 double CBNAME(int a, int b) { \
2981 bool found; \
2982 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2983 double rval; \
2984 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2985 PyObject* ro; \
2986 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2987 if (ro) { \
2988 PyObject* str = PyObject_Str(ro); \
2989 rval = PyFloat_AsDouble(str); \
2990 Py_DECREF(ro); Py_DECREF(str); \
2991 } \
2992 } \
2993 wxPyEndBlockThreads(blocked); \
2994 if (! found) \
2995 rval = PCLASS::CBNAME(a, b); \
2996 return rval; \
2997 }
2998
2999
3000
3001 #define PYCALLBACK__(PCLASS, CBNAME) \
3002 void CBNAME() { \
3003 bool found; \
3004 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3005 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3006 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3007 wxPyEndBlockThreads(blocked); \
3008 if (! found) \
3009 PCLASS::CBNAME(); \
3010 }
3011
3012
3013
3014 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3015 bool CBNAME(size_t a, size_t b) { \
3016 bool rval = 0; \
3017 bool found; \
3018 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3019 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3020 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3021 wxPyEndBlockThreads(blocked); \
3022 if (! found) \
3023 rval = PCLASS::CBNAME(a,b); \
3024 return rval; \
3025 }
3026
3027
3028
3029 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3030 bool CBNAME(size_t a) { \
3031 bool rval = 0; \
3032 bool found; \
3033 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3034 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3035 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3036 wxPyEndBlockThreads(blocked); \
3037 if (! found) \
3038 rval = PCLASS::CBNAME(a); \
3039 return rval; \
3040 }
3041
3042
3043 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3044 wxString CBNAME(int a) { \
3045 bool found; \
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3047 wxString rval; \
3048 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3049 PyObject* ro; \
3050 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3051 if (ro) { \
3052 rval = Py2wxString(ro); \
3053 Py_DECREF(ro); \
3054 } \
3055 } \
3056 wxPyEndBlockThreads(blocked); \
3057 if (! found) \
3058 rval = PCLASS::CBNAME(a); \
3059 return rval; \
3060 }
3061
3062
3063 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3064 void CBNAME(int a, const wxString& c) { \
3065 bool found; \
3066 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3067 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3068 PyObject* s = wx2PyString(c); \
3069 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3070 Py_DECREF(s); \
3071 } \
3072 wxPyEndBlockThreads(blocked); \
3073 if (! found) \
3074 PCLASS::CBNAME(a,c); \
3075 }
3076
3077
3078
3079
3080 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3081 bool CBNAME() { \
3082 bool rval = 0; \
3083 bool found; \
3084 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3085 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3086 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3087 wxPyEndBlockThreads(blocked); \
3088 if (! found) \
3089 rval = PCLASS::CBNAME(); \
3090 return rval; \
3091 }
3092
3093
3094
3095 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3096 void CBNAME(size_t a, int b) { \
3097 bool found; \
3098 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3099 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3100 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3101 wxPyEndBlockThreads(blocked); \
3102 if (! found) \
3103 PCLASS::CBNAME(a,b); \
3104 }
3105
3106
3107
3108
3109 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3110 void CBNAME(int a, int b, long c) { \
3111 bool found; \
3112 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3113 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3114 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3115 wxPyEndBlockThreads(blocked); \
3116 if (! found) \
3117 PCLASS::CBNAME(a,b,c); \
3118 }
3119
3120
3121
3122
3123 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3124 void CBNAME(int a, int b, double c) { \
3125 bool found; \
3126 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3127 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3128 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3129 wxPyEndBlockThreads(blocked); \
3130 if (! found) \
3131 PCLASS::CBNAME(a,b,c); \
3132 }
3133
3134
3135
3136 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3137 void CBNAME(int a, int b, bool c) { \
3138 bool found; \
3139 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3140 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3141 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3142 wxPyEndBlockThreads(blocked); \
3143 if (! found) \
3144 PCLASS::CBNAME(a,b,c); \
3145 }
3146
3147
3148
3149
3150
3151 SWIGINTERN swig_type_info*
3152 SWIG_pchar_descriptor()
3153 {
3154 static int init = 0;
3155 static swig_type_info* info = 0;
3156 if (!init) {
3157 info = SWIG_TypeQuery("_p_char");
3158 init = 1;
3159 }
3160 return info;
3161 }
3162
3163
3164 SWIGINTERNINLINE PyObject *
3165 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3166 {
3167 if (carray) {
3168 if (size > INT_MAX) {
3169 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3170 return pchar_descriptor ?
3171 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3172 } else {
3173 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3174 }
3175 } else {
3176 return SWIG_Py_Void();
3177 }
3178 }
3179
3180
3181 SWIGINTERNINLINE PyObject *
3182 SWIG_FromCharPtr(const char *cptr)
3183 {
3184 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3185 }
3186
3187
3188 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3189 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3190 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3191 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3192 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3193 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3194 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3195 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3196 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3197 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3198
3199
3200 #define SWIG_From_long PyInt_FromLong
3201
3202
3203 SWIGINTERNINLINE PyObject *
3204 SWIG_From_int (int value)
3205 {
3206 return SWIG_From_long (value);
3207 }
3208
3209 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3210 if (!self->GetClientObject())
3211 self->SetClientObject(new wxPyOORClientData(_self));
3212 }
3213 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3214 }
3215
3216 #include <limits.h>
3217 #ifndef LLONG_MIN
3218 # define LLONG_MIN LONG_LONG_MIN
3219 #endif
3220 #ifndef LLONG_MAX
3221 # define LLONG_MAX LONG_LONG_MAX
3222 #endif
3223 #ifndef ULLONG_MAX
3224 # define ULLONG_MAX ULONG_LONG_MAX
3225 #endif
3226
3227
3228 SWIGINTERN int
3229 SWIG_AsVal_long (PyObject* obj, long* val)
3230 {
3231 if (PyNumber_Check(obj)) {
3232 if (val) *val = PyInt_AsLong(obj);
3233 return SWIG_OK;
3234 }
3235 return SWIG_TypeError;
3236 }
3237
3238
3239 SWIGINTERN int
3240 SWIG_AsVal_int (PyObject * obj, int *val)
3241 {
3242 long v;
3243 int res = SWIG_AsVal_long (obj, &v);
3244 if (SWIG_IsOK(res)) {
3245 if ((v < INT_MIN || v > INT_MAX)) {
3246 return SWIG_OverflowError;
3247 } else {
3248 if (val) *val = static_cast< int >(v);
3249 }
3250 }
3251 return res;
3252 }
3253
3254
3255 SWIGINTERN int
3256 SWIG_AsVal_bool (PyObject *obj, bool *val)
3257 {
3258 if (obj == Py_True) {
3259 if (val) *val = true;
3260 return SWIG_OK;
3261 } else if (obj == Py_False) {
3262 if (val) *val = false;
3263 return SWIG_OK;
3264 } else {
3265 long v = 0;
3266 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3267 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3268 return res;
3269 }
3270 }
3271
3272
3273 class wxPyGridCellRenderer : public wxGridCellRenderer
3274 {
3275 public:
3276 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3277
3278 // Implement Python callback aware virtual methods
3279 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3280 wxDC& dc, const wxRect& rect,
3281 int row, int col, bool isSelected) {
3282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3283 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3284 PyObject* go = wxPyMake_wxObject(&grid,false);
3285 PyObject* dco = wxPyMake_wxObject(&dc,false);
3286 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3287 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3288
3289 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3290 row, col, isSelected));
3291 Py_DECREF(go);
3292 Py_DECREF(ao);
3293 Py_DECREF(dco);
3294 Py_DECREF(ro);
3295 }
3296 wxPyEndBlockThreads(blocked);
3297 }
3298
3299 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3300 int row, int col) {
3301 wxSize rval;
3302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3303 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3304 PyObject* ro;
3305 wxSize* ptr;
3306 PyObject* go = wxPyMake_wxObject(&grid,false);
3307 PyObject* dco = wxPyMake_wxObject(&dc,false);
3308 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3309
3310 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3311 go, ao, dco,
3312 row, col));
3313 Py_DECREF(go);
3314 Py_DECREF(ao);
3315 Py_DECREF(dco);
3316
3317 if (ro) {
3318 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3319 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3320 rval = *ptr;
3321 }
3322 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3323 PyObject* o1 = PySequence_GetItem(ro, 0);
3324 PyObject* o2 = PySequence_GetItem(ro, 1);
3325 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3326 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3327 else
3328 PyErr_SetString(PyExc_TypeError, errmsg);
3329 Py_DECREF(o1);
3330 Py_DECREF(o2);
3331 }
3332 else {
3333 PyErr_SetString(PyExc_TypeError, errmsg);
3334 }
3335 Py_DECREF(ro);
3336 }
3337 }
3338 wxPyEndBlockThreads(blocked);
3339 return rval;
3340 }
3341
3342
3343 wxGridCellRenderer *Clone() const {
3344 wxGridCellRenderer* rval = NULL;
3345 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3346 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3347 PyObject* ro;
3348 wxGridCellRenderer* ptr;
3349 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3350 if (ro) {
3351 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3352 rval = ptr;
3353 Py_DECREF(ro);
3354 }
3355 }
3356 wxPyEndBlockThreads(blocked);
3357 return rval;
3358 }
3359
3360 DEC_PYCALLBACK__STRING(SetParameters);
3361
3362 PYPRIVATE;
3363 };
3364
3365 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3366
3367
3368
3369 class wxPyGridCellEditor : public wxGridCellEditor
3370 {
3371 public:
3372 wxPyGridCellEditor() : wxGridCellEditor() {}
3373
3374 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3375 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3376 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3377 PyObject* po = wxPyMake_wxObject(parent,false);
3378 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3379
3380 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3381 Py_DECREF(po);
3382 Py_DECREF(eo);
3383 }
3384 wxPyEndBlockThreads(blocked);
3385 }
3386
3387
3388 void BeginEdit(int row, int col, wxGrid* grid) {
3389 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3390 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3391 PyObject* go = wxPyMake_wxObject(grid,false);
3392 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3393 Py_DECREF(go);
3394 }
3395 wxPyEndBlockThreads(blocked);
3396 }
3397
3398
3399 bool EndEdit(int row, int col, wxGrid* grid) {
3400 bool rv = false;
3401 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3402 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3403 PyObject* go = wxPyMake_wxObject(grid,false);
3404 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3405 Py_DECREF(go);
3406 }
3407 wxPyEndBlockThreads(blocked);
3408 return rv;
3409 }
3410
3411
3412 wxGridCellEditor* Clone() const {
3413 wxGridCellEditor* rval = NULL;
3414 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3415 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3416 PyObject* ro;
3417 wxGridCellEditor* ptr;
3418 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3419 if (ro) {
3420 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3421 rval = ptr;
3422 Py_DECREF(ro);
3423 }
3424 }
3425 wxPyEndBlockThreads(blocked);
3426 return rval;
3427 }
3428
3429
3430 void Show(bool show, wxGridCellAttr *attr) {
3431 bool found;
3432 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3433 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3434 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3435 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3436 Py_DECREF(ao);
3437 }
3438 wxPyEndBlockThreads(blocked);
3439 if (! found)
3440 wxGridCellEditor::Show(show, attr);
3441 }
3442
3443
3444 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3445 bool found;
3446 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3447 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3448 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3449 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3450
3451 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3452
3453 Py_DECREF(ro);
3454 Py_DECREF(ao);
3455 }
3456 wxPyEndBlockThreads(blocked);
3457 if (! found)
3458 wxGridCellEditor::PaintBackground(rectCell, attr);
3459 }
3460
3461
3462 DEC_PYCALLBACK___pure(Reset);
3463 DEC_PYCALLBACK__constany(SetSize, wxRect);
3464 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3465 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3466 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3467 DEC_PYCALLBACK__(StartingClick);
3468 DEC_PYCALLBACK__(Destroy);
3469 DEC_PYCALLBACK__STRING(SetParameters);
3470 DEC_PYCALLBACK_STRING__constpure(GetValue);
3471
3472 PYPRIVATE;
3473 };
3474
3475
3476 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3477 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3478 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3479 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3480 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3481 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3482 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3483 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3484 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3485
3486
3487 static const wxString wxPyOneString(_T("1"));
3488 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3489 if (!self->GetClientObject())
3490 self->SetClientObject(new wxPyOORClientData(_self));
3491 }
3492 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3493 }
3494 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3495 if (!self->GetClientObject())
3496 self->SetClientObject(new wxPyOORClientData(_self));
3497 }
3498
3499 SWIGINTERN int
3500 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3501 {
3502 long v = 0;
3503 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3504 return SWIG_TypeError;
3505 }
3506 else if (val)
3507 *val = (unsigned long)v;
3508 return SWIG_OK;
3509 }
3510
3511
3512 SWIGINTERNINLINE int
3513 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3514 {
3515 unsigned long v;
3516 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3517 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3518 return res;
3519 }
3520
3521
3522 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3523 {
3524 public:
3525 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3526
3527 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3528 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3529 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3530 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3531
3532 PYPRIVATE;
3533 };
3534
3535 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3536 if (!self->GetClientObject())
3537 self->SetClientObject(new wxPyOORClientData(_self));
3538 }
3539
3540 #define SWIG_From_double PyFloat_FromDouble
3541
3542
3543 SWIGINTERN int
3544 SWIG_AsVal_double (PyObject *obj, double* val)
3545 {
3546 if (PyNumber_Check(obj)) {
3547 if (val) *val = PyFloat_AsDouble(obj);
3548 return SWIG_OK;
3549 }
3550 return SWIG_TypeError;
3551 }
3552
3553
3554 class wxPyGridTableBase : public wxGridTableBase
3555 {
3556 public:
3557 wxPyGridTableBase() : wxGridTableBase() {}
3558
3559 PYCALLBACK_INT__pure(GetNumberRows);
3560 PYCALLBACK_INT__pure(GetNumberCols);
3561 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3562 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3563 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3564 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3565 PYCALLBACK__(wxGridTableBase, Clear);
3566 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3567 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3568 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3569 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3570 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3571 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3572 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3573 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3574 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3575 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3576 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3577 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3578 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3579 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3580 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3581
3582
3583 wxString GetValue(int row, int col) {
3584 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3585 wxString rval;
3586 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3587 PyObject* ro;
3588 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3589 if (ro) {
3590 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3591 PyObject* old = ro;
3592 ro = PyObject_Str(ro);
3593 Py_DECREF(old);
3594 }
3595 rval = Py2wxString(ro);
3596 Py_DECREF(ro);
3597 }
3598 }
3599 wxPyEndBlockThreads(blocked);
3600 return rval;
3601 }
3602
3603 void SetValue(int row, int col, const wxString& val) {
3604 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3605 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3606 PyObject* s = wx2PyString(val);
3607 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3608 Py_DECREF(s);
3609 }
3610 wxPyEndBlockThreads(blocked);
3611 }
3612
3613
3614 // Map the Get/Set methods for the standard non-string types to
3615 // the GetValue and SetValue python methods.
3616 long GetValueAsLong( int row, int col ) {
3617 long rval = 0;
3618 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3619 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3620 PyObject* ro;
3621 PyObject* num;
3622 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3623 if (ro && PyNumber_Check(ro)) {
3624 num = PyNumber_Int(ro);
3625 if (num) {
3626 rval = PyInt_AsLong(num);
3627 Py_DECREF(num);
3628 }
3629 Py_DECREF(ro);
3630 }
3631 }
3632 wxPyEndBlockThreads(blocked);
3633 return rval;
3634 }
3635
3636 double GetValueAsDouble( int row, int col ) {
3637 double rval = 0.0;
3638 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3639 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3640 PyObject* ro;
3641 PyObject* num;
3642 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3643 if (ro && PyNumber_Check(ro)) {
3644 num = PyNumber_Float(ro);
3645 if (num) {
3646 rval = PyFloat_AsDouble(num);
3647 Py_DECREF(num);
3648 }
3649 Py_DECREF(ro);
3650 }
3651 }
3652 wxPyEndBlockThreads(blocked);
3653 return rval;
3654 }
3655
3656 bool GetValueAsBool( int row, int col ) {
3657 return (bool)GetValueAsLong(row, col);
3658 }
3659
3660 void SetValueAsLong( int row, int col, long value ) {
3661 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3662 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3663 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3664 }
3665 wxPyEndBlockThreads(blocked);
3666 }
3667
3668 void SetValueAsDouble( int row, int col, double value ) {
3669 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3670 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3671 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3672 }
3673 wxPyEndBlockThreads(blocked);
3674 }
3675
3676 void SetValueAsBool( int row, int col, bool value ) {
3677 SetValueAsLong( row, col, (long)value );
3678 }
3679
3680
3681 PYPRIVATE;
3682 };
3683
3684 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3685
3686 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3687
3688 if (source == Py_None) {
3689 **obj = wxGridCellCoords(-1,-1);
3690 return true;
3691 }
3692
3693 // If source is an object instance then it may already be the right type
3694 if (wxPySwigInstance_Check(source)) {
3695 wxGridCellCoords* ptr;
3696 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3697 goto error;
3698 *obj = ptr;
3699 return true;
3700 }
3701 // otherwise a 2-tuple of integers is expected
3702 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3703 PyObject* o1 = PySequence_GetItem(source, 0);
3704 PyObject* o2 = PySequence_GetItem(source, 1);
3705 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3706 Py_DECREF(o1);
3707 Py_DECREF(o2);
3708 goto error;
3709 }
3710 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3711 Py_DECREF(o1);
3712 Py_DECREF(o2);
3713 return true;
3714 }
3715
3716 error:
3717 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3718 return false;
3719 }
3720
3721
3722 bool wxGridCellCoords_typecheck(PyObject* source) {
3723 void* ptr;
3724
3725 if (wxPySwigInstance_Check(source) &&
3726 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3727 return true;
3728
3729 PyErr_Clear();
3730 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3731 return true;
3732
3733 return false;
3734 }
3735
3736
3737 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3738 {
3739 PyObject* list = PyList_New(0);
3740 size_t idx;
3741 for (idx = 0; idx < source.GetCount(); idx += 1) {
3742 wxGridCellCoords& coord = source.Item(idx);
3743 PyObject* tup = PyTuple_New(2);
3744 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3745 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3746 PyList_Append(list, tup);
3747 Py_DECREF(tup);
3748 }
3749 return list;
3750 }
3751
3752 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3753 wxGridCellCoords temp, *obj = &temp;
3754 if ( other == Py_None ) return false;
3755 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3756 PyErr_Clear();
3757 return false;
3758 }
3759 return self->operator==(*obj);
3760 }
3761 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3762 wxGridCellCoords temp, *obj = &temp;
3763 if ( other == Py_None ) return true;
3764 if ( ! wxGridCellCoords_helper(other, &obj)) {
3765 PyErr_Clear();
3766 return true;
3767 }
3768 return self->operator!=(*obj);
3769 }
3770 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3771 PyObject* tup = PyTuple_New(2);
3772 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3773 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3774 return tup;
3775 }
3776
3777 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3778
3779 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3780 wxGridCellCoords rv;
3781 self->XYToCell(x, y, rv);
3782 return rv;
3783 }
3784 #ifdef __cplusplus
3785 extern "C" {
3786 #endif
3787 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3788 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3789 return 1;
3790 }
3791
3792
3793 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3794 PyObject *pyobj = 0;
3795
3796 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3797 return pyobj;
3798 }
3799
3800
3801 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3802 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3803 return 1;
3804 }
3805
3806
3807 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3808 PyObject *pyobj = 0;
3809
3810 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3811 return pyobj;
3812 }
3813
3814
3815 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj = 0;
3817 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3818 PyObject *arg2 = (PyObject *) 0 ;
3819 void *argp1 = 0 ;
3820 int res1 = 0 ;
3821 PyObject * obj0 = 0 ;
3822 PyObject * obj1 = 0 ;
3823 char * kwnames[] = {
3824 (char *) "self",(char *) "_self", NULL
3825 };
3826
3827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3829 if (!SWIG_IsOK(res1)) {
3830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3831 }
3832 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3833 arg2 = obj1;
3834 {
3835 PyThreadState* __tstate = wxPyBeginAllowThreads();
3836 wxGridCellWorker__setOORInfo(arg1,arg2);
3837 wxPyEndAllowThreads(__tstate);
3838 if (PyErr_Occurred()) SWIG_fail;
3839 }
3840 resultobj = SWIG_Py_Void();
3841 return resultobj;
3842 fail:
3843 return NULL;
3844 }
3845
3846
3847 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3848 PyObject *resultobj = 0;
3849 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3850 void *argp1 = 0 ;
3851 int res1 = 0 ;
3852 PyObject *swig_obj[1] ;
3853
3854 if (!args) SWIG_fail;
3855 swig_obj[0] = args;
3856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3857 if (!SWIG_IsOK(res1)) {
3858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3859 }
3860 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3861 {
3862 PyThreadState* __tstate = wxPyBeginAllowThreads();
3863 delete_wxGridCellWorker(arg1);
3864
3865 wxPyEndAllowThreads(__tstate);
3866 if (PyErr_Occurred()) SWIG_fail;
3867 }
3868 resultobj = SWIG_Py_Void();
3869 return resultobj;
3870 fail:
3871 return NULL;
3872 }
3873
3874
3875 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3876 PyObject *resultobj = 0;
3877 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3878 wxString *arg2 = 0 ;
3879 void *argp1 = 0 ;
3880 int res1 = 0 ;
3881 bool temp2 = false ;
3882 PyObject * obj0 = 0 ;
3883 PyObject * obj1 = 0 ;
3884 char * kwnames[] = {
3885 (char *) "self",(char *) "params", NULL
3886 };
3887
3888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3890 if (!SWIG_IsOK(res1)) {
3891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3892 }
3893 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3894 {
3895 arg2 = wxString_in_helper(obj1);
3896 if (arg2 == NULL) SWIG_fail;
3897 temp2 = true;
3898 }
3899 {
3900 PyThreadState* __tstate = wxPyBeginAllowThreads();
3901 (arg1)->SetParameters((wxString const &)*arg2);
3902 wxPyEndAllowThreads(__tstate);
3903 if (PyErr_Occurred()) SWIG_fail;
3904 }
3905 resultobj = SWIG_Py_Void();
3906 {
3907 if (temp2)
3908 delete arg2;
3909 }
3910 return resultobj;
3911 fail:
3912 {
3913 if (temp2)
3914 delete arg2;
3915 }
3916 return NULL;
3917 }
3918
3919
3920 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3921 PyObject *resultobj = 0;
3922 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3923 void *argp1 = 0 ;
3924 int res1 = 0 ;
3925 PyObject *swig_obj[1] ;
3926
3927 if (!args) SWIG_fail;
3928 swig_obj[0] = args;
3929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3930 if (!SWIG_IsOK(res1)) {
3931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3932 }
3933 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3934 {
3935 PyThreadState* __tstate = wxPyBeginAllowThreads();
3936 (arg1)->IncRef();
3937 wxPyEndAllowThreads(__tstate);
3938 if (PyErr_Occurred()) SWIG_fail;
3939 }
3940 resultobj = SWIG_Py_Void();
3941 return resultobj;
3942 fail:
3943 return NULL;
3944 }
3945
3946
3947 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3948 PyObject *resultobj = 0;
3949 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3950 void *argp1 = 0 ;
3951 int res1 = 0 ;
3952 PyObject *swig_obj[1] ;
3953
3954 if (!args) SWIG_fail;
3955 swig_obj[0] = args;
3956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3957 if (!SWIG_IsOK(res1)) {
3958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3959 }
3960 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3961 {
3962 PyThreadState* __tstate = wxPyBeginAllowThreads();
3963 (arg1)->DecRef();
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 resultobj = SWIG_Py_Void();
3968 return resultobj;
3969 fail:
3970 return NULL;
3971 }
3972
3973
3974 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3975 PyObject *obj;
3976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3977 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3978 return SWIG_Py_Void();
3979 }
3980
3981 SWIGINTERN PyObject *_wrap_GridCellRenderer_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj = 0;
3983 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
3984 wxGrid *arg2 = 0 ;
3985 wxGridCellAttr *arg3 = 0 ;
3986 wxDC *arg4 = 0 ;
3987 wxRect *arg5 = 0 ;
3988 int arg6 ;
3989 int arg7 ;
3990 bool arg8 ;
3991 void *argp1 = 0 ;
3992 int res1 = 0 ;
3993 void *argp2 = 0 ;
3994 int res2 = 0 ;
3995 void *argp3 = 0 ;
3996 int res3 = 0 ;
3997 void *argp4 = 0 ;
3998 int res4 = 0 ;
3999 wxRect temp5 ;
4000 int val6 ;
4001 int ecode6 = 0 ;
4002 int val7 ;
4003 int ecode7 = 0 ;
4004 bool val8 ;
4005 int ecode8 = 0 ;
4006 PyObject * obj0 = 0 ;
4007 PyObject * obj1 = 0 ;
4008 PyObject * obj2 = 0 ;
4009 PyObject * obj3 = 0 ;
4010 PyObject * obj4 = 0 ;
4011 PyObject * obj5 = 0 ;
4012 PyObject * obj6 = 0 ;
4013 PyObject * obj7 = 0 ;
4014 char * kwnames[] = {
4015 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "rect",(char *) "row",(char *) "col",(char *) "isSelected", NULL
4016 };
4017
4018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO:GridCellRenderer_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4020 if (!SWIG_IsOK(res1)) {
4021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Draw" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4022 }
4023 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4025 if (!SWIG_IsOK(res2)) {
4026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4027 }
4028 if (!argp2) {
4029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "2"" of type '" "wxGrid &""'");
4030 }
4031 arg2 = reinterpret_cast< wxGrid * >(argp2);
4032 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4033 if (!SWIG_IsOK(res3)) {
4034 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4035 }
4036 if (!argp3) {
4037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4038 }
4039 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4040 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4041 if (!SWIG_IsOK(res4)) {
4042 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4043 }
4044 if (!argp4) {
4045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_Draw" "', expected argument " "4"" of type '" "wxDC &""'");
4046 }
4047 arg4 = reinterpret_cast< wxDC * >(argp4);
4048 {
4049 arg5 = &temp5;
4050 if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;
4051 }
4052 ecode6 = SWIG_AsVal_int(obj5, &val6);
4053 if (!SWIG_IsOK(ecode6)) {
4054 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_Draw" "', expected argument " "6"" of type '" "int""'");
4055 }
4056 arg6 = static_cast< int >(val6);
4057 ecode7 = SWIG_AsVal_int(obj6, &val7);
4058 if (!SWIG_IsOK(ecode7)) {
4059 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GridCellRenderer_Draw" "', expected argument " "7"" of type '" "int""'");
4060 }
4061 arg7 = static_cast< int >(val7);
4062 ecode8 = SWIG_AsVal_bool(obj7, &val8);
4063 if (!SWIG_IsOK(ecode8)) {
4064 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GridCellRenderer_Draw" "', expected argument " "8"" of type '" "bool""'");
4065 }
4066 arg8 = static_cast< bool >(val8);
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 (arg1)->Draw(*arg2,*arg3,*arg4,(wxRect const &)*arg5,arg6,arg7,arg8);
4070 wxPyEndAllowThreads(__tstate);
4071 if (PyErr_Occurred()) SWIG_fail;
4072 }
4073 resultobj = SWIG_Py_Void();
4074 return resultobj;
4075 fail:
4076 return NULL;
4077 }
4078
4079
4080 SWIGINTERN PyObject *_wrap_GridCellRenderer_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4081 PyObject *resultobj = 0;
4082 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4083 wxGrid *arg2 = 0 ;
4084 wxGridCellAttr *arg3 = 0 ;
4085 wxDC *arg4 = 0 ;
4086 int arg5 ;
4087 int arg6 ;
4088 wxSize result;
4089 void *argp1 = 0 ;
4090 int res1 = 0 ;
4091 void *argp2 = 0 ;
4092 int res2 = 0 ;
4093 void *argp3 = 0 ;
4094 int res3 = 0 ;
4095 void *argp4 = 0 ;
4096 int res4 = 0 ;
4097 int val5 ;
4098 int ecode5 = 0 ;
4099 int val6 ;
4100 int ecode6 = 0 ;
4101 PyObject * obj0 = 0 ;
4102 PyObject * obj1 = 0 ;
4103 PyObject * obj2 = 0 ;
4104 PyObject * obj3 = 0 ;
4105 PyObject * obj4 = 0 ;
4106 PyObject * obj5 = 0 ;
4107 char * kwnames[] = {
4108 (char *) "self",(char *) "grid",(char *) "attr",(char *) "dc",(char *) "row",(char *) "col", NULL
4109 };
4110
4111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:GridCellRenderer_GetBestSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4113 if (!SWIG_IsOK(res1)) {
4114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "1"" of type '" "wxGridCellRenderer *""'");
4115 }
4116 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGrid, 0 );
4118 if (!SWIG_IsOK(res2)) {
4119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4120 }
4121 if (!argp2) {
4122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "2"" of type '" "wxGrid &""'");
4123 }
4124 arg2 = reinterpret_cast< wxGrid * >(argp2);
4125 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxGridCellAttr, 0 );
4126 if (!SWIG_IsOK(res3)) {
4127 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4128 }
4129 if (!argp3) {
4130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "3"" of type '" "wxGridCellAttr &""'");
4131 }
4132 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4133 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDC, 0 );
4134 if (!SWIG_IsOK(res4)) {
4135 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4136 }
4137 if (!argp4) {
4138 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "4"" of type '" "wxDC &""'");
4139 }
4140 arg4 = reinterpret_cast< wxDC * >(argp4);
4141 ecode5 = SWIG_AsVal_int(obj4, &val5);
4142 if (!SWIG_IsOK(ecode5)) {
4143 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "5"" of type '" "int""'");
4144 }
4145 arg5 = static_cast< int >(val5);
4146 ecode6 = SWIG_AsVal_int(obj5, &val6);
4147 if (!SWIG_IsOK(ecode6)) {
4148 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridCellRenderer_GetBestSize" "', expected argument " "6"" of type '" "int""'");
4149 }
4150 arg6 = static_cast< int >(val6);
4151 {
4152 PyThreadState* __tstate = wxPyBeginAllowThreads();
4153 result = (arg1)->GetBestSize(*arg2,*arg3,*arg4,arg5,arg6);
4154 wxPyEndAllowThreads(__tstate);
4155 if (PyErr_Occurred()) SWIG_fail;
4156 }
4157 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4158 return resultobj;
4159 fail:
4160 return NULL;
4161 }
4162
4163
4164 SWIGINTERN PyObject *_wrap_GridCellRenderer_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4165 PyObject *resultobj = 0;
4166 wxGridCellRenderer *arg1 = (wxGridCellRenderer *) 0 ;
4167 wxGridCellRenderer *result = 0 ;
4168 void *argp1 = 0 ;
4169 int res1 = 0 ;
4170 PyObject *swig_obj[1] ;
4171
4172 if (!args) SWIG_fail;
4173 swig_obj[0] = args;
4174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
4175 if (!SWIG_IsOK(res1)) {
4176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellRenderer_Clone" "', expected argument " "1"" of type '" "wxGridCellRenderer const *""'");
4177 }
4178 arg1 = reinterpret_cast< wxGridCellRenderer * >(argp1);
4179 {
4180 PyThreadState* __tstate = wxPyBeginAllowThreads();
4181 result = (wxGridCellRenderer *)((wxGridCellRenderer const *)arg1)->Clone();
4182 wxPyEndAllowThreads(__tstate);
4183 if (PyErr_Occurred()) SWIG_fail;
4184 }
4185 {
4186 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
4187 }
4188 return resultobj;
4189 fail:
4190 return NULL;
4191 }
4192
4193
4194 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4195 PyObject *obj;
4196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4197 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
4198 return SWIG_Py_Void();
4199 }
4200
4201 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4202 PyObject *resultobj = 0;
4203 wxPyGridCellRenderer *result = 0 ;
4204
4205 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
4213 return resultobj;
4214 fail:
4215 return NULL;
4216 }
4217
4218
4219 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4220 PyObject *resultobj = 0;
4221 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4222 PyObject *arg2 = (PyObject *) 0 ;
4223 PyObject *arg3 = (PyObject *) 0 ;
4224 void *argp1 = 0 ;
4225 int res1 = 0 ;
4226 PyObject * obj0 = 0 ;
4227 PyObject * obj1 = 0 ;
4228 PyObject * obj2 = 0 ;
4229 char * kwnames[] = {
4230 (char *) "self",(char *) "self",(char *) "_class", NULL
4231 };
4232
4233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4235 if (!SWIG_IsOK(res1)) {
4236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4237 }
4238 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4239 arg2 = obj1;
4240 arg3 = obj2;
4241 {
4242 PyThreadState* __tstate = wxPyBeginAllowThreads();
4243 (arg1)->_setCallbackInfo(arg2,arg3);
4244 wxPyEndAllowThreads(__tstate);
4245 if (PyErr_Occurred()) SWIG_fail;
4246 }
4247 resultobj = SWIG_Py_Void();
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
4254 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4255 PyObject *resultobj = 0;
4256 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4257 wxString *arg2 = 0 ;
4258 void *argp1 = 0 ;
4259 int res1 = 0 ;
4260 bool temp2 = false ;
4261 PyObject * obj0 = 0 ;
4262 PyObject * obj1 = 0 ;
4263 char * kwnames[] = {
4264 (char *) "self",(char *) "params", NULL
4265 };
4266
4267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4269 if (!SWIG_IsOK(res1)) {
4270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4271 }
4272 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4273 {
4274 arg2 = wxString_in_helper(obj1);
4275 if (arg2 == NULL) SWIG_fail;
4276 temp2 = true;
4277 }
4278 {
4279 PyThreadState* __tstate = wxPyBeginAllowThreads();
4280 (arg1)->SetParameters((wxString const &)*arg2);
4281 wxPyEndAllowThreads(__tstate);
4282 if (PyErr_Occurred()) SWIG_fail;
4283 }
4284 resultobj = SWIG_Py_Void();
4285 {
4286 if (temp2)
4287 delete arg2;
4288 }
4289 return resultobj;
4290 fail:
4291 {
4292 if (temp2)
4293 delete arg2;
4294 }
4295 return NULL;
4296 }
4297
4298
4299 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4300 PyObject *obj;
4301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4302 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4303 return SWIG_Py_Void();
4304 }
4305
4306 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4307 return SWIG_Python_InitShadowInstance(args);
4308 }
4309
4310 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4311 PyObject *resultobj = 0;
4312 wxGridCellStringRenderer *result = 0 ;
4313
4314 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4315 {
4316 PyThreadState* __tstate = wxPyBeginAllowThreads();
4317 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4318 wxPyEndAllowThreads(__tstate);
4319 if (PyErr_Occurred()) SWIG_fail;
4320 }
4321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4322 return resultobj;
4323 fail:
4324 return NULL;
4325 }
4326
4327
4328 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4329 PyObject *obj;
4330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4331 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4332 return SWIG_Py_Void();
4333 }
4334
4335 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4336 return SWIG_Python_InitShadowInstance(args);
4337 }
4338
4339 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4340 PyObject *resultobj = 0;
4341 wxGridCellNumberRenderer *result = 0 ;
4342
4343 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4344 {
4345 PyThreadState* __tstate = wxPyBeginAllowThreads();
4346 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4347 wxPyEndAllowThreads(__tstate);
4348 if (PyErr_Occurred()) SWIG_fail;
4349 }
4350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4351 return resultobj;
4352 fail:
4353 return NULL;
4354 }
4355
4356
4357 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4358 PyObject *obj;
4359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4360 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4361 return SWIG_Py_Void();
4362 }
4363
4364 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4365 return SWIG_Python_InitShadowInstance(args);
4366 }
4367
4368 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj = 0;
4370 int arg1 = (int) -1 ;
4371 int arg2 = (int) -1 ;
4372 wxGridCellFloatRenderer *result = 0 ;
4373 int val1 ;
4374 int ecode1 = 0 ;
4375 int val2 ;
4376 int ecode2 = 0 ;
4377 PyObject * obj0 = 0 ;
4378 PyObject * obj1 = 0 ;
4379 char * kwnames[] = {
4380 (char *) "width",(char *) "precision", NULL
4381 };
4382
4383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4384 if (obj0) {
4385 ecode1 = SWIG_AsVal_int(obj0, &val1);
4386 if (!SWIG_IsOK(ecode1)) {
4387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4388 }
4389 arg1 = static_cast< int >(val1);
4390 }
4391 if (obj1) {
4392 ecode2 = SWIG_AsVal_int(obj1, &val2);
4393 if (!SWIG_IsOK(ecode2)) {
4394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4395 }
4396 arg2 = static_cast< int >(val2);
4397 }
4398 {
4399 PyThreadState* __tstate = wxPyBeginAllowThreads();
4400 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4401 wxPyEndAllowThreads(__tstate);
4402 if (PyErr_Occurred()) SWIG_fail;
4403 }
4404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4405 return resultobj;
4406 fail:
4407 return NULL;
4408 }
4409
4410
4411 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4412 PyObject *resultobj = 0;
4413 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4414 int result;
4415 void *argp1 = 0 ;
4416 int res1 = 0 ;
4417 PyObject *swig_obj[1] ;
4418
4419 if (!args) SWIG_fail;
4420 swig_obj[0] = args;
4421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4422 if (!SWIG_IsOK(res1)) {
4423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4424 }
4425 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4426 {
4427 PyThreadState* __tstate = wxPyBeginAllowThreads();
4428 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4429 wxPyEndAllowThreads(__tstate);
4430 if (PyErr_Occurred()) SWIG_fail;
4431 }
4432 resultobj = SWIG_From_int(static_cast< int >(result));
4433 return resultobj;
4434 fail:
4435 return NULL;
4436 }
4437
4438
4439 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4440 PyObject *resultobj = 0;
4441 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4442 int arg2 ;
4443 void *argp1 = 0 ;
4444 int res1 = 0 ;
4445 int val2 ;
4446 int ecode2 = 0 ;
4447 PyObject * obj0 = 0 ;
4448 PyObject * obj1 = 0 ;
4449 char * kwnames[] = {
4450 (char *) "self",(char *) "width", NULL
4451 };
4452
4453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4455 if (!SWIG_IsOK(res1)) {
4456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4457 }
4458 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4459 ecode2 = SWIG_AsVal_int(obj1, &val2);
4460 if (!SWIG_IsOK(ecode2)) {
4461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4462 }
4463 arg2 = static_cast< int >(val2);
4464 {
4465 PyThreadState* __tstate = wxPyBeginAllowThreads();
4466 (arg1)->SetWidth(arg2);
4467 wxPyEndAllowThreads(__tstate);
4468 if (PyErr_Occurred()) SWIG_fail;
4469 }
4470 resultobj = SWIG_Py_Void();
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4478 PyObject *resultobj = 0;
4479 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4480 int result;
4481 void *argp1 = 0 ;
4482 int res1 = 0 ;
4483 PyObject *swig_obj[1] ;
4484
4485 if (!args) SWIG_fail;
4486 swig_obj[0] = args;
4487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4488 if (!SWIG_IsOK(res1)) {
4489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4490 }
4491 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4492 {
4493 PyThreadState* __tstate = wxPyBeginAllowThreads();
4494 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 resultobj = SWIG_From_int(static_cast< int >(result));
4499 return resultobj;
4500 fail:
4501 return NULL;
4502 }
4503
4504
4505 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4506 PyObject *resultobj = 0;
4507 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4508 int arg2 ;
4509 void *argp1 = 0 ;
4510 int res1 = 0 ;
4511 int val2 ;
4512 int ecode2 = 0 ;
4513 PyObject * obj0 = 0 ;
4514 PyObject * obj1 = 0 ;
4515 char * kwnames[] = {
4516 (char *) "self",(char *) "precision", NULL
4517 };
4518
4519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4523 }
4524 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4525 ecode2 = SWIG_AsVal_int(obj1, &val2);
4526 if (!SWIG_IsOK(ecode2)) {
4527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4528 }
4529 arg2 = static_cast< int >(val2);
4530 {
4531 PyThreadState* __tstate = wxPyBeginAllowThreads();
4532 (arg1)->SetPrecision(arg2);
4533 wxPyEndAllowThreads(__tstate);
4534 if (PyErr_Occurred()) SWIG_fail;
4535 }
4536 resultobj = SWIG_Py_Void();
4537 return resultobj;
4538 fail:
4539 return NULL;
4540 }
4541
4542
4543 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4544 PyObject *obj;
4545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4546 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4547 return SWIG_Py_Void();
4548 }
4549
4550 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4551 return SWIG_Python_InitShadowInstance(args);
4552 }
4553
4554 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4555 PyObject *resultobj = 0;
4556 wxGridCellBoolRenderer *result = 0 ;
4557
4558 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4559 {
4560 PyThreadState* __tstate = wxPyBeginAllowThreads();
4561 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4562 wxPyEndAllowThreads(__tstate);
4563 if (PyErr_Occurred()) SWIG_fail;
4564 }
4565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4566 return resultobj;
4567 fail:
4568 return NULL;
4569 }
4570
4571
4572 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573 PyObject *obj;
4574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4575 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4576 return SWIG_Py_Void();
4577 }
4578
4579 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580 return SWIG_Python_InitShadowInstance(args);
4581 }
4582
4583 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4584 PyObject *resultobj = 0;
4585 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4586 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4587 wxGridCellDateTimeRenderer *result = 0 ;
4588 PyObject * obj0 = 0 ;
4589 PyObject * obj1 = 0 ;
4590 char * kwnames[] = {
4591 (char *) "outformat",(char *) "informat", NULL
4592 };
4593
4594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4595 if (obj0) {
4596 {
4597 wxString* sptr = wxString_in_helper(obj0);
4598 if (sptr == NULL) SWIG_fail;
4599 arg1 = *sptr;
4600 delete sptr;
4601 }
4602 }
4603 if (obj1) {
4604 {
4605 wxString* sptr = wxString_in_helper(obj1);
4606 if (sptr == NULL) SWIG_fail;
4607 arg2 = *sptr;
4608 delete sptr;
4609 }
4610 }
4611 {
4612 PyThreadState* __tstate = wxPyBeginAllowThreads();
4613 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4625 PyObject *obj;
4626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4627 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4628 return SWIG_Py_Void();
4629 }
4630
4631 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4632 return SWIG_Python_InitShadowInstance(args);
4633 }
4634
4635 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj = 0;
4637 wxString const &arg1_defvalue = wxPyEmptyString ;
4638 wxString *arg1 = (wxString *) &arg1_defvalue ;
4639 wxGridCellEnumRenderer *result = 0 ;
4640 bool temp1 = false ;
4641 PyObject * obj0 = 0 ;
4642 char * kwnames[] = {
4643 (char *) "choices", NULL
4644 };
4645
4646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4647 if (obj0) {
4648 {
4649 arg1 = wxString_in_helper(obj0);
4650 if (arg1 == NULL) SWIG_fail;
4651 temp1 = true;
4652 }
4653 }
4654 {
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4657 wxPyEndAllowThreads(__tstate);
4658 if (PyErr_Occurred()) SWIG_fail;
4659 }
4660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4661 {
4662 if (temp1)
4663 delete arg1;
4664 }
4665 return resultobj;
4666 fail:
4667 {
4668 if (temp1)
4669 delete arg1;
4670 }
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4676 PyObject *obj;
4677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4678 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4679 return SWIG_Py_Void();
4680 }
4681
4682 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4683 return SWIG_Python_InitShadowInstance(args);
4684 }
4685
4686 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4687 PyObject *resultobj = 0;
4688 wxGridCellAutoWrapStringRenderer *result = 0 ;
4689
4690 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4691 {
4692 PyThreadState* __tstate = wxPyBeginAllowThreads();
4693 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4705 PyObject *obj;
4706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4707 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4708 return SWIG_Py_Void();
4709 }
4710
4711 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4712 return SWIG_Python_InitShadowInstance(args);
4713 }
4714
4715 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4716 PyObject *resultobj = 0;
4717 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4718 bool result;
4719 void *argp1 = 0 ;
4720 int res1 = 0 ;
4721 PyObject *swig_obj[1] ;
4722
4723 if (!args) SWIG_fail;
4724 swig_obj[0] = args;
4725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4728 }
4729 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4730 {
4731 PyThreadState* __tstate = wxPyBeginAllowThreads();
4732 result = (bool)(arg1)->IsCreated();
4733 wxPyEndAllowThreads(__tstate);
4734 if (PyErr_Occurred()) SWIG_fail;
4735 }
4736 {
4737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4738 }
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4746 PyObject *resultobj = 0;
4747 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4748 wxControl *result = 0 ;
4749 void *argp1 = 0 ;
4750 int res1 = 0 ;
4751 PyObject *swig_obj[1] ;
4752
4753 if (!args) SWIG_fail;
4754 swig_obj[0] = args;
4755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4758 }
4759 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4760 {
4761 PyThreadState* __tstate = wxPyBeginAllowThreads();
4762 result = (wxControl *)(arg1)->GetControl();
4763 wxPyEndAllowThreads(__tstate);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 {
4767 resultobj = wxPyMake_wxObject(result, 0);
4768 }
4769 return resultobj;
4770 fail:
4771 return NULL;
4772 }
4773
4774
4775 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4776 PyObject *resultobj = 0;
4777 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4778 wxControl *arg2 = (wxControl *) 0 ;
4779 void *argp1 = 0 ;
4780 int res1 = 0 ;
4781 void *argp2 = 0 ;
4782 int res2 = 0 ;
4783 PyObject * obj0 = 0 ;
4784 PyObject * obj1 = 0 ;
4785 char * kwnames[] = {
4786 (char *) "self",(char *) "control", NULL
4787 };
4788
4789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4791 if (!SWIG_IsOK(res1)) {
4792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4793 }
4794 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4796 if (!SWIG_IsOK(res2)) {
4797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4798 }
4799 arg2 = reinterpret_cast< wxControl * >(argp2);
4800 {
4801 PyThreadState* __tstate = wxPyBeginAllowThreads();
4802 (arg1)->SetControl(arg2);
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 resultobj = SWIG_Py_Void();
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4814 PyObject *resultobj = 0;
4815 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4816 wxGridCellAttr *result = 0 ;
4817 void *argp1 = 0 ;
4818 int res1 = 0 ;
4819 PyObject *swig_obj[1] ;
4820
4821 if (!args) SWIG_fail;
4822 swig_obj[0] = args;
4823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4824 if (!SWIG_IsOK(res1)) {
4825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4826 }
4827 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4828 {
4829 PyThreadState* __tstate = wxPyBeginAllowThreads();
4830 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4831 wxPyEndAllowThreads(__tstate);
4832 if (PyErr_Occurred()) SWIG_fail;
4833 }
4834 {
4835 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4836 }
4837 return resultobj;
4838 fail:
4839 return NULL;
4840 }
4841
4842
4843 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4844 PyObject *resultobj = 0;
4845 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4846 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4847 void *argp1 = 0 ;
4848 int res1 = 0 ;
4849 void *argp2 = 0 ;
4850 int res2 = 0 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 char * kwnames[] = {
4854 (char *) "self",(char *) "attr", NULL
4855 };
4856
4857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4859 if (!SWIG_IsOK(res1)) {
4860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4861 }
4862 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4863 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4864 if (!SWIG_IsOK(res2)) {
4865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4866 }
4867 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 (arg1)->SetCellAttr(arg2);
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_Py_Void();
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4884 wxWindow *arg2 = (wxWindow *) 0 ;
4885 int arg3 ;
4886 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 void *argp2 = 0 ;
4890 int res2 = 0 ;
4891 int val3 ;
4892 int ecode3 = 0 ;
4893 void *argp4 = 0 ;
4894 int res4 = 0 ;
4895 PyObject * obj0 = 0 ;
4896 PyObject * obj1 = 0 ;
4897 PyObject * obj2 = 0 ;
4898 PyObject * obj3 = 0 ;
4899 char * kwnames[] = {
4900 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4901 };
4902
4903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4905 if (!SWIG_IsOK(res1)) {
4906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4907 }
4908 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4910 if (!SWIG_IsOK(res2)) {
4911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4912 }
4913 arg2 = reinterpret_cast< wxWindow * >(argp2);
4914 ecode3 = SWIG_AsVal_int(obj2, &val3);
4915 if (!SWIG_IsOK(ecode3)) {
4916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4917 }
4918 arg3 = static_cast< int >(val3);
4919 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4920 if (!SWIG_IsOK(res4)) {
4921 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4922 }
4923 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4924 {
4925 PyThreadState* __tstate = wxPyBeginAllowThreads();
4926 (arg1)->Create(arg2,arg3,arg4);
4927 wxPyEndAllowThreads(__tstate);
4928 if (PyErr_Occurred()) SWIG_fail;
4929 }
4930 resultobj = SWIG_Py_Void();
4931 return resultobj;
4932 fail:
4933 return NULL;
4934 }
4935
4936
4937 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4938 PyObject *resultobj = 0;
4939 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4940 int arg2 ;
4941 int arg3 ;
4942 wxGrid *arg4 = (wxGrid *) 0 ;
4943 void *argp1 = 0 ;
4944 int res1 = 0 ;
4945 int val2 ;
4946 int ecode2 = 0 ;
4947 int val3 ;
4948 int ecode3 = 0 ;
4949 void *argp4 = 0 ;
4950 int res4 = 0 ;
4951 PyObject * obj0 = 0 ;
4952 PyObject * obj1 = 0 ;
4953 PyObject * obj2 = 0 ;
4954 PyObject * obj3 = 0 ;
4955 char * kwnames[] = {
4956 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4957 };
4958
4959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4961 if (!SWIG_IsOK(res1)) {
4962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4963 }
4964 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4965 ecode2 = SWIG_AsVal_int(obj1, &val2);
4966 if (!SWIG_IsOK(ecode2)) {
4967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4968 }
4969 arg2 = static_cast< int >(val2);
4970 ecode3 = SWIG_AsVal_int(obj2, &val3);
4971 if (!SWIG_IsOK(ecode3)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4973 }
4974 arg3 = static_cast< int >(val3);
4975 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4976 if (!SWIG_IsOK(res4)) {
4977 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4978 }
4979 arg4 = reinterpret_cast< wxGrid * >(argp4);
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 (arg1)->BeginEdit(arg2,arg3,arg4);
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 resultobj = SWIG_Py_Void();
4987 return resultobj;
4988 fail:
4989 return NULL;
4990 }
4991
4992
4993 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4994 PyObject *resultobj = 0;
4995 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4996 int arg2 ;
4997 int arg3 ;
4998 wxGrid *arg4 = (wxGrid *) 0 ;
4999 bool result;
5000 void *argp1 = 0 ;
5001 int res1 = 0 ;
5002 int val2 ;
5003 int ecode2 = 0 ;
5004 int val3 ;
5005 int ecode3 = 0 ;
5006 void *argp4 = 0 ;
5007 int res4 = 0 ;
5008 PyObject * obj0 = 0 ;
5009 PyObject * obj1 = 0 ;
5010 PyObject * obj2 = 0 ;
5011 PyObject * obj3 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5020 }
5021 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5022 ecode2 = SWIG_AsVal_int(obj1, &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
5025 }
5026 arg2 = static_cast< int >(val2);
5027 ecode3 = SWIG_AsVal_int(obj2, &val3);
5028 if (!SWIG_IsOK(ecode3)) {
5029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
5030 }
5031 arg3 = static_cast< int >(val3);
5032 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
5033 if (!SWIG_IsOK(res4)) {
5034 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
5035 }
5036 arg4 = reinterpret_cast< wxGrid * >(argp4);
5037 {
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 {
5044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5045 }
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5053 PyObject *resultobj = 0;
5054 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5055 void *argp1 = 0 ;
5056 int res1 = 0 ;
5057 PyObject *swig_obj[1] ;
5058
5059 if (!args) SWIG_fail;
5060 swig_obj[0] = args;
5061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5062 if (!SWIG_IsOK(res1)) {
5063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5064 }
5065 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5066 {
5067 PyThreadState* __tstate = wxPyBeginAllowThreads();
5068 (arg1)->Reset();
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 resultobj = SWIG_Py_Void();
5073 return resultobj;
5074 fail:
5075 return NULL;
5076 }
5077
5078
5079 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5080 PyObject *resultobj = 0;
5081 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5082 wxGridCellEditor *result = 0 ;
5083 void *argp1 = 0 ;
5084 int res1 = 0 ;
5085 PyObject *swig_obj[1] ;
5086
5087 if (!args) SWIG_fail;
5088 swig_obj[0] = args;
5089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5090 if (!SWIG_IsOK(res1)) {
5091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
5092 }
5093 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5094 {
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
5097 wxPyEndAllowThreads(__tstate);
5098 if (PyErr_Occurred()) SWIG_fail;
5099 }
5100 {
5101 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
5102 }
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5110 PyObject *resultobj = 0;
5111 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5112 wxRect *arg2 = 0 ;
5113 void *argp1 = 0 ;
5114 int res1 = 0 ;
5115 wxRect temp2 ;
5116 PyObject * obj0 = 0 ;
5117 PyObject * obj1 = 0 ;
5118 char * kwnames[] = {
5119 (char *) "self",(char *) "rect", NULL
5120 };
5121
5122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
5123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5124 if (!SWIG_IsOK(res1)) {
5125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5126 }
5127 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5128 {
5129 arg2 = &temp2;
5130 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5131 }
5132 {
5133 PyThreadState* __tstate = wxPyBeginAllowThreads();
5134 (arg1)->SetSize((wxRect const &)*arg2);
5135 wxPyEndAllowThreads(__tstate);
5136 if (PyErr_Occurred()) SWIG_fail;
5137 }
5138 resultobj = SWIG_Py_Void();
5139 return resultobj;
5140 fail:
5141 return NULL;
5142 }
5143
5144
5145 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5146 PyObject *resultobj = 0;
5147 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5148 bool arg2 ;
5149 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 bool val2 ;
5153 int ecode2 = 0 ;
5154 void *argp3 = 0 ;
5155 int res3 = 0 ;
5156 PyObject * obj0 = 0 ;
5157 PyObject * obj1 = 0 ;
5158 PyObject * obj2 = 0 ;
5159 char * kwnames[] = {
5160 (char *) "self",(char *) "show",(char *) "attr", NULL
5161 };
5162
5163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5165 if (!SWIG_IsOK(res1)) {
5166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5167 }
5168 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5169 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5170 if (!SWIG_IsOK(ecode2)) {
5171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
5172 }
5173 arg2 = static_cast< bool >(val2);
5174 if (obj2) {
5175 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5176 if (!SWIG_IsOK(res3)) {
5177 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5178 }
5179 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5180 }
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 (arg1)->Show(arg2,arg3);
5184 wxPyEndAllowThreads(__tstate);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 resultobj = SWIG_Py_Void();
5188 return resultobj;
5189 fail:
5190 return NULL;
5191 }
5192
5193
5194 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5195 PyObject *resultobj = 0;
5196 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5197 wxRect *arg2 = 0 ;
5198 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
5199 void *argp1 = 0 ;
5200 int res1 = 0 ;
5201 wxRect temp2 ;
5202 void *argp3 = 0 ;
5203 int res3 = 0 ;
5204 PyObject * obj0 = 0 ;
5205 PyObject * obj1 = 0 ;
5206 PyObject * obj2 = 0 ;
5207 char * kwnames[] = {
5208 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
5209 };
5210
5211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5215 }
5216 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5217 {
5218 arg2 = &temp2;
5219 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5220 }
5221 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5222 if (!SWIG_IsOK(res3)) {
5223 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5224 }
5225 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5226 {
5227 PyThreadState* __tstate = wxPyBeginAllowThreads();
5228 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5229 wxPyEndAllowThreads(__tstate);
5230 if (PyErr_Occurred()) SWIG_fail;
5231 }
5232 resultobj = SWIG_Py_Void();
5233 return resultobj;
5234 fail:
5235 return NULL;
5236 }
5237
5238
5239 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5240 PyObject *resultobj = 0;
5241 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5242 wxKeyEvent *arg2 = 0 ;
5243 bool result;
5244 void *argp1 = 0 ;
5245 int res1 = 0 ;
5246 void *argp2 = 0 ;
5247 int res2 = 0 ;
5248 PyObject * obj0 = 0 ;
5249 PyObject * obj1 = 0 ;
5250 char * kwnames[] = {
5251 (char *) "self",(char *) "event", NULL
5252 };
5253
5254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5256 if (!SWIG_IsOK(res1)) {
5257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5258 }
5259 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5260 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5261 if (!SWIG_IsOK(res2)) {
5262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5263 }
5264 if (!argp2) {
5265 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5266 }
5267 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5268 {
5269 PyThreadState* __tstate = wxPyBeginAllowThreads();
5270 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5271 wxPyEndAllowThreads(__tstate);
5272 if (PyErr_Occurred()) SWIG_fail;
5273 }
5274 {
5275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5276 }
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj = 0;
5285 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5286 wxKeyEvent *arg2 = 0 ;
5287 void *argp1 = 0 ;
5288 int res1 = 0 ;
5289 void *argp2 = 0 ;
5290 int res2 = 0 ;
5291 PyObject * obj0 = 0 ;
5292 PyObject * obj1 = 0 ;
5293 char * kwnames[] = {
5294 (char *) "self",(char *) "event", NULL
5295 };
5296
5297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5299 if (!SWIG_IsOK(res1)) {
5300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5301 }
5302 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5303 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5304 if (!SWIG_IsOK(res2)) {
5305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5306 }
5307 if (!argp2) {
5308 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5309 }
5310 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5311 {
5312 PyThreadState* __tstate = wxPyBeginAllowThreads();
5313 (arg1)->StartingKey(*arg2);
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 resultobj = SWIG_Py_Void();
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5325 PyObject *resultobj = 0;
5326 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5327 void *argp1 = 0 ;
5328 int res1 = 0 ;
5329 PyObject *swig_obj[1] ;
5330
5331 if (!args) SWIG_fail;
5332 swig_obj[0] = args;
5333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5334 if (!SWIG_IsOK(res1)) {
5335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5336 }
5337 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5338 {
5339 PyThreadState* __tstate = wxPyBeginAllowThreads();
5340 (arg1)->StartingClick();
5341 wxPyEndAllowThreads(__tstate);
5342 if (PyErr_Occurred()) SWIG_fail;
5343 }
5344 resultobj = SWIG_Py_Void();
5345 return resultobj;
5346 fail:
5347 return NULL;
5348 }
5349
5350
5351 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5352 PyObject *resultobj = 0;
5353 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5354 wxKeyEvent *arg2 = 0 ;
5355 void *argp1 = 0 ;
5356 int res1 = 0 ;
5357 void *argp2 = 0 ;
5358 int res2 = 0 ;
5359 PyObject * obj0 = 0 ;
5360 PyObject * obj1 = 0 ;
5361 char * kwnames[] = {
5362 (char *) "self",(char *) "event", NULL
5363 };
5364
5365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5367 if (!SWIG_IsOK(res1)) {
5368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5369 }
5370 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5371 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5372 if (!SWIG_IsOK(res2)) {
5373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5374 }
5375 if (!argp2) {
5376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5377 }
5378 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5379 {
5380 PyThreadState* __tstate = wxPyBeginAllowThreads();
5381 (arg1)->HandleReturn(*arg2);
5382 wxPyEndAllowThreads(__tstate);
5383 if (PyErr_Occurred()) SWIG_fail;
5384 }
5385 resultobj = SWIG_Py_Void();
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5395 void *argp1 = 0 ;
5396 int res1 = 0 ;
5397 PyObject *swig_obj[1] ;
5398
5399 if (!args) SWIG_fail;
5400 swig_obj[0] = args;
5401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5402 if (!SWIG_IsOK(res1)) {
5403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5404 }
5405 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5406 {
5407 PyThreadState* __tstate = wxPyBeginAllowThreads();
5408 (arg1)->Destroy();
5409 wxPyEndAllowThreads(__tstate);
5410 if (PyErr_Occurred()) SWIG_fail;
5411 }
5412 resultobj = SWIG_Py_Void();
5413 return resultobj;
5414 fail:
5415 return NULL;
5416 }
5417
5418
5419 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5420 PyObject *obj;
5421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5422 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5423 return SWIG_Py_Void();
5424 }
5425
5426 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5427 PyObject *resultobj = 0;
5428 wxPyGridCellEditor *result = 0 ;
5429
5430 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5431 {
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj = 0;
5446 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5447 PyObject *arg2 = (PyObject *) 0 ;
5448 PyObject *arg3 = (PyObject *) 0 ;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 PyObject * obj0 = 0 ;
5452 PyObject * obj1 = 0 ;
5453 PyObject * obj2 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "self",(char *) "_class", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5462 }
5463 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5464 arg2 = obj1;
5465 arg3 = obj2;
5466 {
5467 PyThreadState* __tstate = wxPyBeginAllowThreads();
5468 (arg1)->_setCallbackInfo(arg2,arg3);
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 resultobj = SWIG_Py_Void();
5473 return resultobj;
5474 fail:
5475 return NULL;
5476 }
5477
5478
5479 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5480 PyObject *resultobj = 0;
5481 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5482 wxString *arg2 = 0 ;
5483 void *argp1 = 0 ;
5484 int res1 = 0 ;
5485 bool temp2 = false ;
5486 PyObject * obj0 = 0 ;
5487 PyObject * obj1 = 0 ;
5488 char * kwnames[] = {
5489 (char *) "self",(char *) "params", NULL
5490 };
5491
5492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5494 if (!SWIG_IsOK(res1)) {
5495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5496 }
5497 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5498 {
5499 arg2 = wxString_in_helper(obj1);
5500 if (arg2 == NULL) SWIG_fail;
5501 temp2 = true;
5502 }
5503 {
5504 PyThreadState* __tstate = wxPyBeginAllowThreads();
5505 (arg1)->SetParameters((wxString const &)*arg2);
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 resultobj = SWIG_Py_Void();
5510 {
5511 if (temp2)
5512 delete arg2;
5513 }
5514 return resultobj;
5515 fail:
5516 {
5517 if (temp2)
5518 delete arg2;
5519 }
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5525 PyObject *obj;
5526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5527 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5528 return SWIG_Py_Void();
5529 }
5530
5531 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5532 return SWIG_Python_InitShadowInstance(args);
5533 }
5534
5535 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5536 PyObject *resultobj = 0;
5537 wxGridCellTextEditor *result = 0 ;
5538
5539 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5540 {
5541 PyThreadState* __tstate = wxPyBeginAllowThreads();
5542 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5543 wxPyEndAllowThreads(__tstate);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5547 return resultobj;
5548 fail:
5549 return NULL;
5550 }
5551
5552
5553 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5554 PyObject *resultobj = 0;
5555 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5556 wxString result;
5557 void *argp1 = 0 ;
5558 int res1 = 0 ;
5559 PyObject *swig_obj[1] ;
5560
5561 if (!args) SWIG_fail;
5562 swig_obj[0] = args;
5563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5564 if (!SWIG_IsOK(res1)) {
5565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5566 }
5567 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5568 {
5569 PyThreadState* __tstate = wxPyBeginAllowThreads();
5570 result = (arg1)->GetValue();
5571 wxPyEndAllowThreads(__tstate);
5572 if (PyErr_Occurred()) SWIG_fail;
5573 }
5574 {
5575 #if wxUSE_UNICODE
5576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5577 #else
5578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5579 #endif
5580 }
5581 return resultobj;
5582 fail:
5583 return NULL;
5584 }
5585
5586
5587 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5588 PyObject *obj;
5589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5590 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5591 return SWIG_Py_Void();
5592 }
5593
5594 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5595 return SWIG_Python_InitShadowInstance(args);
5596 }
5597
5598 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj = 0;
5600 int arg1 = (int) -1 ;
5601 int arg2 = (int) -1 ;
5602 wxGridCellNumberEditor *result = 0 ;
5603 int val1 ;
5604 int ecode1 = 0 ;
5605 int val2 ;
5606 int ecode2 = 0 ;
5607 PyObject * obj0 = 0 ;
5608 PyObject * obj1 = 0 ;
5609 char * kwnames[] = {
5610 (char *) "min",(char *) "max", NULL
5611 };
5612
5613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5614 if (obj0) {
5615 ecode1 = SWIG_AsVal_int(obj0, &val1);
5616 if (!SWIG_IsOK(ecode1)) {
5617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5618 }
5619 arg1 = static_cast< int >(val1);
5620 }
5621 if (obj1) {
5622 ecode2 = SWIG_AsVal_int(obj1, &val2);
5623 if (!SWIG_IsOK(ecode2)) {
5624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5625 }
5626 arg2 = static_cast< int >(val2);
5627 }
5628 {
5629 PyThreadState* __tstate = wxPyBeginAllowThreads();
5630 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5631 wxPyEndAllowThreads(__tstate);
5632 if (PyErr_Occurred()) SWIG_fail;
5633 }
5634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642 PyObject *obj;
5643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5644 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5645 return SWIG_Py_Void();
5646 }
5647
5648 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5649 return SWIG_Python_InitShadowInstance(args);
5650 }
5651
5652 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5653 PyObject *resultobj = 0;
5654 int arg1 = (int) -1 ;
5655 int arg2 = (int) -1 ;
5656 wxGridCellFloatEditor *result = 0 ;
5657 int val1 ;
5658 int ecode1 = 0 ;
5659 int val2 ;
5660 int ecode2 = 0 ;
5661 PyObject * obj0 = 0 ;
5662 PyObject * obj1 = 0 ;
5663 char * kwnames[] = {
5664 (char *) "width",(char *) "precision", NULL
5665 };
5666
5667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5668 if (obj0) {
5669 ecode1 = SWIG_AsVal_int(obj0, &val1);
5670 if (!SWIG_IsOK(ecode1)) {
5671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5672 }
5673 arg1 = static_cast< int >(val1);
5674 }
5675 if (obj1) {
5676 ecode2 = SWIG_AsVal_int(obj1, &val2);
5677 if (!SWIG_IsOK(ecode2)) {
5678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5679 }
5680 arg2 = static_cast< int >(val2);
5681 }
5682 {
5683 PyThreadState* __tstate = wxPyBeginAllowThreads();
5684 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5685 wxPyEndAllowThreads(__tstate);
5686 if (PyErr_Occurred()) SWIG_fail;
5687 }
5688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5689 return resultobj;
5690 fail:
5691 return NULL;
5692 }
5693
5694
5695 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5696 PyObject *obj;
5697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5698 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5699 return SWIG_Py_Void();
5700 }
5701
5702 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5703 return SWIG_Python_InitShadowInstance(args);
5704 }
5705
5706 SWIGINTERN int OneString_set(PyObject *) {
5707 SWIG_Error(SWIG_AttributeError,"Variable OneString is read-only.");
5708 return 1;
5709 }
5710
5711
5712 SWIGINTERN PyObject *OneString_get(void) {
5713 PyObject *pyobj = 0;
5714
5715 {
5716 #if wxUSE_UNICODE
5717 pyobj = PyUnicode_FromWideChar((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5718 #else
5719 pyobj = PyString_FromStringAndSize((&wxPyOneString)->c_str(), (&wxPyOneString)->Len());
5720 #endif
5721 }
5722 return pyobj;
5723 }
5724
5725
5726 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5727 PyObject *resultobj = 0;
5728 wxGridCellBoolEditor *result = 0 ;
5729
5730 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5731 {
5732 PyThreadState* __tstate = wxPyBeginAllowThreads();
5733 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5734 wxPyEndAllowThreads(__tstate);
5735 if (PyErr_Occurred()) SWIG_fail;
5736 }
5737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5738 return resultobj;
5739 fail:
5740 return NULL;
5741 }
5742
5743
5744 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_UseStringValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5745 PyObject *resultobj = 0;
5746 wxString const &arg1_defvalue = wxPyOneString ;
5747 wxString *arg1 = (wxString *) &arg1_defvalue ;
5748 wxString const &arg2_defvalue = wxPyEmptyString ;
5749 wxString *arg2 = (wxString *) &arg2_defvalue ;
5750 bool temp1 = false ;
5751 bool temp2 = false ;
5752 PyObject * obj0 = 0 ;
5753 PyObject * obj1 = 0 ;
5754 char * kwnames[] = {
5755 (char *) "valueTrue",(char *) "valueFalse", NULL
5756 };
5757
5758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:GridCellBoolEditor_UseStringValues",kwnames,&obj0,&obj1)) SWIG_fail;
5759 if (obj0) {
5760 {
5761 arg1 = wxString_in_helper(obj0);
5762 if (arg1 == NULL) SWIG_fail;
5763 temp1 = true;
5764 }
5765 }
5766 if (obj1) {
5767 {
5768 arg2 = wxString_in_helper(obj1);
5769 if (arg2 == NULL) SWIG_fail;
5770 temp2 = true;
5771 }
5772 }
5773 {
5774 PyThreadState* __tstate = wxPyBeginAllowThreads();
5775 wxGridCellBoolEditor::UseStringValues((wxString const &)*arg1,(wxString const &)*arg2);
5776 wxPyEndAllowThreads(__tstate);
5777 if (PyErr_Occurred()) SWIG_fail;
5778 }
5779 resultobj = SWIG_Py_Void();
5780 {
5781 if (temp1)
5782 delete arg1;
5783 }
5784 {
5785 if (temp2)
5786 delete arg2;
5787 }
5788 return resultobj;
5789 fail:
5790 {
5791 if (temp1)
5792 delete arg1;
5793 }
5794 {
5795 if (temp2)
5796 delete arg2;
5797 }
5798 return NULL;
5799 }
5800
5801
5802 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_IsTrueValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5803 PyObject *resultobj = 0;
5804 wxString *arg1 = 0 ;
5805 bool result;
5806 bool temp1 = false ;
5807 PyObject * obj0 = 0 ;
5808 char * kwnames[] = {
5809 (char *) "value", NULL
5810 };
5811
5812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridCellBoolEditor_IsTrueValue",kwnames,&obj0)) SWIG_fail;
5813 {
5814 arg1 = wxString_in_helper(obj0);
5815 if (arg1 == NULL) SWIG_fail;
5816 temp1 = true;
5817 }
5818 {
5819 PyThreadState* __tstate = wxPyBeginAllowThreads();
5820 result = (bool)wxGridCellBoolEditor::IsTrueValue((wxString const &)*arg1);
5821 wxPyEndAllowThreads(__tstate);
5822 if (PyErr_Occurred()) SWIG_fail;
5823 }
5824 {
5825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5826 }
5827 {
5828 if (temp1)
5829 delete arg1;
5830 }
5831 return resultobj;
5832 fail:
5833 {
5834 if (temp1)
5835 delete arg1;
5836 }
5837 return NULL;
5838 }
5839
5840
5841 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5842 PyObject *obj;
5843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5844 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5845 return SWIG_Py_Void();
5846 }
5847
5848 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5849 return SWIG_Python_InitShadowInstance(args);
5850 }
5851
5852 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5853 PyObject *resultobj = 0;
5854 int arg1 = (int) 0 ;
5855 wxString *arg2 = (wxString *) NULL ;
5856 bool arg3 = (bool) false ;
5857 wxGridCellChoiceEditor *result = 0 ;
5858 bool val3 ;
5859 int ecode3 = 0 ;
5860 PyObject * obj0 = 0 ;
5861 PyObject * obj1 = 0 ;
5862 char * kwnames[] = {
5863 (char *) "choices",(char *) "allowOthers", NULL
5864 };
5865
5866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5867 if (obj0) {
5868 {
5869 arg1 = PyList_Size(obj0);
5870 arg2 = wxString_LIST_helper(obj0);
5871 if (arg2 == NULL) SWIG_fail;
5872 }
5873 }
5874 if (obj1) {
5875 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5876 if (!SWIG_IsOK(ecode3)) {
5877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5878 }
5879 arg3 = static_cast< bool >(val3);
5880 }
5881 {
5882 PyThreadState* __tstate = wxPyBeginAllowThreads();
5883 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5884 wxPyEndAllowThreads(__tstate);
5885 if (PyErr_Occurred()) SWIG_fail;
5886 }
5887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5888 {
5889 if (arg2) delete [] arg2;
5890 }
5891 return resultobj;
5892 fail:
5893 {
5894 if (arg2) delete [] arg2;
5895 }
5896 return NULL;
5897 }
5898
5899
5900 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5901 PyObject *obj;
5902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5903 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5904 return SWIG_Py_Void();
5905 }
5906
5907 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5908 return SWIG_Python_InitShadowInstance(args);
5909 }
5910
5911 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5912 PyObject *resultobj = 0;
5913 wxString const &arg1_defvalue = wxPyEmptyString ;
5914 wxString *arg1 = (wxString *) &arg1_defvalue ;
5915 wxGridCellEnumEditor *result = 0 ;
5916 bool temp1 = false ;
5917 PyObject * obj0 = 0 ;
5918 char * kwnames[] = {
5919 (char *) "choices", NULL
5920 };
5921
5922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5923 if (obj0) {
5924 {
5925 arg1 = wxString_in_helper(obj0);
5926 if (arg1 == NULL) SWIG_fail;
5927 temp1 = true;
5928 }
5929 }
5930 {
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5933 wxPyEndAllowThreads(__tstate);
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5937 {
5938 if (temp1)
5939 delete arg1;
5940 }
5941 return resultobj;
5942 fail:
5943 {
5944 if (temp1)
5945 delete arg1;
5946 }
5947 return NULL;
5948 }
5949
5950
5951 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5952 PyObject *obj;
5953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5954 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5955 return SWIG_Py_Void();
5956 }
5957
5958 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5959 return SWIG_Python_InitShadowInstance(args);
5960 }
5961
5962 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5963 PyObject *resultobj = 0;
5964 wxGridCellAutoWrapStringEditor *result = 0 ;
5965
5966 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5981 PyObject *obj;
5982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5983 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5984 return SWIG_Py_Void();
5985 }
5986
5987 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5988 return SWIG_Python_InitShadowInstance(args);
5989 }
5990
5991 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5992 PyObject *resultobj = 0;
5993 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5994 PyObject *arg2 = (PyObject *) 0 ;
5995 void *argp1 = 0 ;
5996 int res1 = 0 ;
5997 PyObject * obj0 = 0 ;
5998 PyObject * obj1 = 0 ;
5999 char * kwnames[] = {
6000 (char *) "self",(char *) "_self", NULL
6001 };
6002
6003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
6004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6005 if (!SWIG_IsOK(res1)) {
6006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6007 }
6008 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6009 arg2 = obj1;
6010 {
6011 PyThreadState* __tstate = wxPyBeginAllowThreads();
6012 wxGridCellAttr__setOORInfo(arg1,arg2);
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 resultobj = SWIG_Py_Void();
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj = 0;
6025 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
6026 wxGridCellAttr *result = 0 ;
6027 void *argp1 = 0 ;
6028 int res1 = 0 ;
6029 PyObject * obj0 = 0 ;
6030 char * kwnames[] = {
6031 (char *) "attrDefault", NULL
6032 };
6033
6034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
6035 if (obj0) {
6036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6037 if (!SWIG_IsOK(res1)) {
6038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6039 }
6040 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6041 }
6042 {
6043 PyThreadState* __tstate = wxPyBeginAllowThreads();
6044 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
6045 wxPyEndAllowThreads(__tstate);
6046 if (PyErr_Occurred()) SWIG_fail;
6047 }
6048 {
6049 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
6050 }
6051 return resultobj;
6052 fail:
6053 return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6058 PyObject *resultobj = 0;
6059 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6060 void *argp1 = 0 ;
6061 int res1 = 0 ;
6062 PyObject *swig_obj[1] ;
6063
6064 if (!args) SWIG_fail;
6065 swig_obj[0] = args;
6066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
6067 if (!SWIG_IsOK(res1)) {
6068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6069 }
6070 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6071 {
6072 PyThreadState* __tstate = wxPyBeginAllowThreads();
6073 delete_wxGridCellAttr(arg1);
6074
6075 wxPyEndAllowThreads(__tstate);
6076 if (PyErr_Occurred()) SWIG_fail;
6077 }
6078 resultobj = SWIG_Py_Void();
6079 return resultobj;
6080 fail:
6081 return NULL;
6082 }
6083
6084
6085 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6086 PyObject *resultobj = 0;
6087 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6088 wxGridCellAttr *result = 0 ;
6089 void *argp1 = 0 ;
6090 int res1 = 0 ;
6091 PyObject *swig_obj[1] ;
6092
6093 if (!args) SWIG_fail;
6094 swig_obj[0] = args;
6095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6096 if (!SWIG_IsOK(res1)) {
6097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6098 }
6099 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6100 {
6101 PyThreadState* __tstate = wxPyBeginAllowThreads();
6102 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
6103 wxPyEndAllowThreads(__tstate);
6104 if (PyErr_Occurred()) SWIG_fail;
6105 }
6106 {
6107 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
6108 }
6109 return resultobj;
6110 fail:
6111 return NULL;
6112 }
6113
6114
6115 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj = 0;
6117 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6118 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6119 void *argp1 = 0 ;
6120 int res1 = 0 ;
6121 void *argp2 = 0 ;
6122 int res2 = 0 ;
6123 PyObject * obj0 = 0 ;
6124 PyObject * obj1 = 0 ;
6125 char * kwnames[] = {
6126 (char *) "self",(char *) "mergefrom", NULL
6127 };
6128
6129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
6130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6131 if (!SWIG_IsOK(res1)) {
6132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6133 }
6134 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6136 if (!SWIG_IsOK(res2)) {
6137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6138 }
6139 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6140 {
6141 PyThreadState* __tstate = wxPyBeginAllowThreads();
6142 (arg1)->MergeWith(arg2);
6143 wxPyEndAllowThreads(__tstate);
6144 if (PyErr_Occurred()) SWIG_fail;
6145 }
6146 resultobj = SWIG_Py_Void();
6147 return resultobj;
6148 fail:
6149 return NULL;
6150 }
6151
6152
6153 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6154 PyObject *resultobj = 0;
6155 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6156 void *argp1 = 0 ;
6157 int res1 = 0 ;
6158 PyObject *swig_obj[1] ;
6159
6160 if (!args) SWIG_fail;
6161 swig_obj[0] = args;
6162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6163 if (!SWIG_IsOK(res1)) {
6164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6165 }
6166 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6167 {
6168 PyThreadState* __tstate = wxPyBeginAllowThreads();
6169 (arg1)->IncRef();
6170 wxPyEndAllowThreads(__tstate);
6171 if (PyErr_Occurred()) SWIG_fail;
6172 }
6173 resultobj = SWIG_Py_Void();
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6181 PyObject *resultobj = 0;
6182 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6183 void *argp1 = 0 ;
6184 int res1 = 0 ;
6185 PyObject *swig_obj[1] ;
6186
6187 if (!args) SWIG_fail;
6188 swig_obj[0] = args;
6189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6190 if (!SWIG_IsOK(res1)) {
6191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6192 }
6193 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6194 {
6195 PyThreadState* __tstate = wxPyBeginAllowThreads();
6196 (arg1)->DecRef();
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 resultobj = SWIG_Py_Void();
6201 return resultobj;
6202 fail:
6203 return NULL;
6204 }
6205
6206
6207 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj = 0;
6209 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6210 wxColour *arg2 = 0 ;
6211 void *argp1 = 0 ;
6212 int res1 = 0 ;
6213 wxColour temp2 ;
6214 PyObject * obj0 = 0 ;
6215 PyObject * obj1 = 0 ;
6216 char * kwnames[] = {
6217 (char *) "self",(char *) "colText", NULL
6218 };
6219
6220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
6221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6222 if (!SWIG_IsOK(res1)) {
6223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6224 }
6225 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6226 {
6227 arg2 = &temp2;
6228 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6229 }
6230 {
6231 PyThreadState* __tstate = wxPyBeginAllowThreads();
6232 (arg1)->SetTextColour((wxColour const &)*arg2);
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 resultobj = SWIG_Py_Void();
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6244 PyObject *resultobj = 0;
6245 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6246 wxColour *arg2 = 0 ;
6247 void *argp1 = 0 ;
6248 int res1 = 0 ;
6249 wxColour temp2 ;
6250 PyObject * obj0 = 0 ;
6251 PyObject * obj1 = 0 ;
6252 char * kwnames[] = {
6253 (char *) "self",(char *) "colBack", NULL
6254 };
6255
6256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
6257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6258 if (!SWIG_IsOK(res1)) {
6259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6260 }
6261 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6262 {
6263 arg2 = &temp2;
6264 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6265 }
6266 {
6267 PyThreadState* __tstate = wxPyBeginAllowThreads();
6268 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
6269 wxPyEndAllowThreads(__tstate);
6270 if (PyErr_Occurred()) SWIG_fail;
6271 }
6272 resultobj = SWIG_Py_Void();
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj = 0;
6281 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6282 wxFont *arg2 = 0 ;
6283 void *argp1 = 0 ;
6284 int res1 = 0 ;
6285 void *argp2 = 0 ;
6286 int res2 = 0 ;
6287 PyObject * obj0 = 0 ;
6288 PyObject * obj1 = 0 ;
6289 char * kwnames[] = {
6290 (char *) "self",(char *) "font", NULL
6291 };
6292
6293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6295 if (!SWIG_IsOK(res1)) {
6296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6297 }
6298 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6300 if (!SWIG_IsOK(res2)) {
6301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6302 }
6303 if (!argp2) {
6304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6305 }
6306 arg2 = reinterpret_cast< wxFont * >(argp2);
6307 {
6308 PyThreadState* __tstate = wxPyBeginAllowThreads();
6309 (arg1)->SetFont((wxFont const &)*arg2);
6310 wxPyEndAllowThreads(__tstate);
6311 if (PyErr_Occurred()) SWIG_fail;
6312 }
6313 resultobj = SWIG_Py_Void();
6314 return resultobj;
6315 fail:
6316 return NULL;
6317 }
6318
6319
6320 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6321 PyObject *resultobj = 0;
6322 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6323 int arg2 ;
6324 int arg3 ;
6325 void *argp1 = 0 ;
6326 int res1 = 0 ;
6327 int val2 ;
6328 int ecode2 = 0 ;
6329 int val3 ;
6330 int ecode3 = 0 ;
6331 PyObject * obj0 = 0 ;
6332 PyObject * obj1 = 0 ;
6333 PyObject * obj2 = 0 ;
6334 char * kwnames[] = {
6335 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6336 };
6337
6338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6340 if (!SWIG_IsOK(res1)) {
6341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6342 }
6343 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6344 ecode2 = SWIG_AsVal_int(obj1, &val2);
6345 if (!SWIG_IsOK(ecode2)) {
6346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6347 }
6348 arg2 = static_cast< int >(val2);
6349 ecode3 = SWIG_AsVal_int(obj2, &val3);
6350 if (!SWIG_IsOK(ecode3)) {
6351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6352 }
6353 arg3 = static_cast< int >(val3);
6354 {
6355 PyThreadState* __tstate = wxPyBeginAllowThreads();
6356 (arg1)->SetAlignment(arg2,arg3);
6357 wxPyEndAllowThreads(__tstate);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 resultobj = SWIG_Py_Void();
6361 return resultobj;
6362 fail:
6363 return NULL;
6364 }
6365
6366
6367 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6368 PyObject *resultobj = 0;
6369 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6370 int arg2 ;
6371 int arg3 ;
6372 void *argp1 = 0 ;
6373 int res1 = 0 ;
6374 int val2 ;
6375 int ecode2 = 0 ;
6376 int val3 ;
6377 int ecode3 = 0 ;
6378 PyObject * obj0 = 0 ;
6379 PyObject * obj1 = 0 ;
6380 PyObject * obj2 = 0 ;
6381 char * kwnames[] = {
6382 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6383 };
6384
6385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6387 if (!SWIG_IsOK(res1)) {
6388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6389 }
6390 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6391 ecode2 = SWIG_AsVal_int(obj1, &val2);
6392 if (!SWIG_IsOK(ecode2)) {
6393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6394 }
6395 arg2 = static_cast< int >(val2);
6396 ecode3 = SWIG_AsVal_int(obj2, &val3);
6397 if (!SWIG_IsOK(ecode3)) {
6398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6399 }
6400 arg3 = static_cast< int >(val3);
6401 {
6402 PyThreadState* __tstate = wxPyBeginAllowThreads();
6403 (arg1)->SetSize(arg2,arg3);
6404 wxPyEndAllowThreads(__tstate);
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 resultobj = SWIG_Py_Void();
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj = 0;
6416 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6417 bool arg2 = (bool) true ;
6418 void *argp1 = 0 ;
6419 int res1 = 0 ;
6420 bool val2 ;
6421 int ecode2 = 0 ;
6422 PyObject * obj0 = 0 ;
6423 PyObject * obj1 = 0 ;
6424 char * kwnames[] = {
6425 (char *) "self",(char *) "allow", NULL
6426 };
6427
6428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6430 if (!SWIG_IsOK(res1)) {
6431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6432 }
6433 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6434 if (obj1) {
6435 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6436 if (!SWIG_IsOK(ecode2)) {
6437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6438 }
6439 arg2 = static_cast< bool >(val2);
6440 }
6441 {
6442 PyThreadState* __tstate = wxPyBeginAllowThreads();
6443 (arg1)->SetOverflow(arg2);
6444 wxPyEndAllowThreads(__tstate);
6445 if (PyErr_Occurred()) SWIG_fail;
6446 }
6447 resultobj = SWIG_Py_Void();
6448 return resultobj;
6449 fail:
6450 return NULL;
6451 }
6452
6453
6454 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6455 PyObject *resultobj = 0;
6456 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6457 bool arg2 = (bool) true ;
6458 void *argp1 = 0 ;
6459 int res1 = 0 ;
6460 bool val2 ;
6461 int ecode2 = 0 ;
6462 PyObject * obj0 = 0 ;
6463 PyObject * obj1 = 0 ;
6464 char * kwnames[] = {
6465 (char *) "self",(char *) "isReadOnly", NULL
6466 };
6467
6468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6470 if (!SWIG_IsOK(res1)) {
6471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6472 }
6473 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6474 if (obj1) {
6475 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6476 if (!SWIG_IsOK(ecode2)) {
6477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6478 }
6479 arg2 = static_cast< bool >(val2);
6480 }
6481 {
6482 PyThreadState* __tstate = wxPyBeginAllowThreads();
6483 (arg1)->SetReadOnly(arg2);
6484 wxPyEndAllowThreads(__tstate);
6485 if (PyErr_Occurred()) SWIG_fail;
6486 }
6487 resultobj = SWIG_Py_Void();
6488 return resultobj;
6489 fail:
6490 return NULL;
6491 }
6492
6493
6494 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6495 PyObject *resultobj = 0;
6496 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6497 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6498 void *argp1 = 0 ;
6499 int res1 = 0 ;
6500 void *argp2 = 0 ;
6501 int res2 = 0 ;
6502 PyObject * obj0 = 0 ;
6503 PyObject * obj1 = 0 ;
6504 char * kwnames[] = {
6505 (char *) "self",(char *) "renderer", NULL
6506 };
6507
6508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6510 if (!SWIG_IsOK(res1)) {
6511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6512 }
6513 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6515 if (!SWIG_IsOK(res2)) {
6516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6517 }
6518 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6519 {
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 (arg1)->SetRenderer(arg2);
6522 wxPyEndAllowThreads(__tstate);
6523 if (PyErr_Occurred()) SWIG_fail;
6524 }
6525 resultobj = SWIG_Py_Void();
6526 return resultobj;
6527 fail:
6528 return NULL;
6529 }
6530
6531
6532 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6533 PyObject *resultobj = 0;
6534 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6535 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6536 void *argp1 = 0 ;
6537 int res1 = 0 ;
6538 void *argp2 = 0 ;
6539 int res2 = 0 ;
6540 PyObject * obj0 = 0 ;
6541 PyObject * obj1 = 0 ;
6542 char * kwnames[] = {
6543 (char *) "self",(char *) "editor", NULL
6544 };
6545
6546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6548 if (!SWIG_IsOK(res1)) {
6549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6550 }
6551 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6552 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6553 if (!SWIG_IsOK(res2)) {
6554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6555 }
6556 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 (arg1)->SetEditor(arg2);
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_Py_Void();
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj = 0;
6572 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6573 wxGridCellAttr::wxAttrKind arg2 ;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 int val2 ;
6577 int ecode2 = 0 ;
6578 PyObject * obj0 = 0 ;
6579 PyObject * obj1 = 0 ;
6580 char * kwnames[] = {
6581 (char *) "self",(char *) "kind", NULL
6582 };
6583
6584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6586 if (!SWIG_IsOK(res1)) {
6587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6588 }
6589 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6590 ecode2 = SWIG_AsVal_int(obj1, &val2);
6591 if (!SWIG_IsOK(ecode2)) {
6592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6593 }
6594 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6595 {
6596 PyThreadState* __tstate = wxPyBeginAllowThreads();
6597 (arg1)->SetKind(arg2);
6598 wxPyEndAllowThreads(__tstate);
6599 if (PyErr_Occurred()) SWIG_fail;
6600 }
6601 resultobj = SWIG_Py_Void();
6602 return resultobj;
6603 fail:
6604 return NULL;
6605 }
6606
6607
6608 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6609 PyObject *resultobj = 0;
6610 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6611 bool result;
6612 void *argp1 = 0 ;
6613 int res1 = 0 ;
6614 PyObject *swig_obj[1] ;
6615
6616 if (!args) SWIG_fail;
6617 swig_obj[0] = args;
6618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6619 if (!SWIG_IsOK(res1)) {
6620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6621 }
6622 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6623 {
6624 PyThreadState* __tstate = wxPyBeginAllowThreads();
6625 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 {
6630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6631 }
6632 return resultobj;
6633 fail:
6634 return NULL;
6635 }
6636
6637
6638 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6639 PyObject *resultobj = 0;
6640 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6641 bool result;
6642 void *argp1 = 0 ;
6643 int res1 = 0 ;
6644 PyObject *swig_obj[1] ;
6645
6646 if (!args) SWIG_fail;
6647 swig_obj[0] = args;
6648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6651 }
6652 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6656 wxPyEndAllowThreads(__tstate);
6657 if (PyErr_Occurred()) SWIG_fail;
6658 }
6659 {
6660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6661 }
6662 return resultobj;
6663 fail:
6664 return NULL;
6665 }
6666
6667
6668 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6669 PyObject *resultobj = 0;
6670 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6671 bool result;
6672 void *argp1 = 0 ;
6673 int res1 = 0 ;
6674 PyObject *swig_obj[1] ;
6675
6676 if (!args) SWIG_fail;
6677 swig_obj[0] = args;
6678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6679 if (!SWIG_IsOK(res1)) {
6680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6681 }
6682 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6686 wxPyEndAllowThreads(__tstate);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 {
6690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6691 }
6692 return resultobj;
6693 fail:
6694 return NULL;
6695 }
6696
6697
6698 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6699 PyObject *resultobj = 0;
6700 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6701 bool result;
6702 void *argp1 = 0 ;
6703 int res1 = 0 ;
6704 PyObject *swig_obj[1] ;
6705
6706 if (!args) SWIG_fail;
6707 swig_obj[0] = args;
6708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6709 if (!SWIG_IsOK(res1)) {
6710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6711 }
6712 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6713 {
6714 PyThreadState* __tstate = wxPyBeginAllowThreads();
6715 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 {
6720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6721 }
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6729 PyObject *resultobj = 0;
6730 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6731 bool result;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 PyObject *swig_obj[1] ;
6735
6736 if (!args) SWIG_fail;
6737 swig_obj[0] = args;
6738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6739 if (!SWIG_IsOK(res1)) {
6740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6741 }
6742 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 {
6750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6751 }
6752 return resultobj;
6753 fail:
6754 return NULL;
6755 }
6756
6757
6758 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6759 PyObject *resultobj = 0;
6760 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6761 bool result;
6762 void *argp1 = 0 ;
6763 int res1 = 0 ;
6764 PyObject *swig_obj[1] ;
6765
6766 if (!args) SWIG_fail;
6767 swig_obj[0] = args;
6768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6769 if (!SWIG_IsOK(res1)) {
6770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6771 }
6772 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6773 {
6774 PyThreadState* __tstate = wxPyBeginAllowThreads();
6775 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6776 wxPyEndAllowThreads(__tstate);
6777 if (PyErr_Occurred()) SWIG_fail;
6778 }
6779 {
6780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6781 }
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6789 PyObject *resultobj = 0;
6790 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6791 bool result;
6792 void *argp1 = 0 ;
6793 int res1 = 0 ;
6794 PyObject *swig_obj[1] ;
6795
6796 if (!args) SWIG_fail;
6797 swig_obj[0] = args;
6798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6799 if (!SWIG_IsOK(res1)) {
6800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6801 }
6802 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6803 {
6804 PyThreadState* __tstate = wxPyBeginAllowThreads();
6805 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 {
6810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6811 }
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6819 PyObject *resultobj = 0;
6820 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6821 bool result;
6822 void *argp1 = 0 ;
6823 int res1 = 0 ;
6824 PyObject *swig_obj[1] ;
6825
6826 if (!args) SWIG_fail;
6827 swig_obj[0] = args;
6828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6829 if (!SWIG_IsOK(res1)) {
6830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6831 }
6832 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6833 {
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 {
6840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6841 }
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6849 PyObject *resultobj = 0;
6850 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6851 wxColour result;
6852 void *argp1 = 0 ;
6853 int res1 = 0 ;
6854 PyObject *swig_obj[1] ;
6855
6856 if (!args) SWIG_fail;
6857 swig_obj[0] = args;
6858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6859 if (!SWIG_IsOK(res1)) {
6860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6861 }
6862 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6866 wxPyEndAllowThreads(__tstate);
6867 if (PyErr_Occurred()) SWIG_fail;
6868 }
6869 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6870 return resultobj;
6871 fail:
6872 return NULL;
6873 }
6874
6875
6876 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6877 PyObject *resultobj = 0;
6878 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6879 wxColour result;
6880 void *argp1 = 0 ;
6881 int res1 = 0 ;
6882 PyObject *swig_obj[1] ;
6883
6884 if (!args) SWIG_fail;
6885 swig_obj[0] = args;
6886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6887 if (!SWIG_IsOK(res1)) {
6888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6889 }
6890 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6891 {
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6905 PyObject *resultobj = 0;
6906 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6907 wxFont result;
6908 void *argp1 = 0 ;
6909 int res1 = 0 ;
6910 PyObject *swig_obj[1] ;
6911
6912 if (!args) SWIG_fail;
6913 swig_obj[0] = args;
6914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6915 if (!SWIG_IsOK(res1)) {
6916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6917 }
6918 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6919 {
6920 PyThreadState* __tstate = wxPyBeginAllowThreads();
6921 result = ((wxGridCellAttr const *)arg1)->GetFont();
6922 wxPyEndAllowThreads(__tstate);
6923 if (PyErr_Occurred()) SWIG_fail;
6924 }
6925 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6926 return resultobj;
6927 fail:
6928 return NULL;
6929 }
6930
6931
6932 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6933 PyObject *resultobj = 0;
6934 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6935 int *arg2 = (int *) 0 ;
6936 int *arg3 = (int *) 0 ;
6937 void *argp1 = 0 ;
6938 int res1 = 0 ;
6939 int temp2 ;
6940 int res2 = SWIG_TMPOBJ ;
6941 int temp3 ;
6942 int res3 = SWIG_TMPOBJ ;
6943 PyObject *swig_obj[1] ;
6944
6945 arg2 = &temp2;
6946 arg3 = &temp3;
6947 if (!args) SWIG_fail;
6948 swig_obj[0] = args;
6949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6950 if (!SWIG_IsOK(res1)) {
6951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6952 }
6953 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6954 {
6955 PyThreadState* __tstate = wxPyBeginAllowThreads();
6956 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6957 wxPyEndAllowThreads(__tstate);
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 resultobj = SWIG_Py_Void();
6961 if (SWIG_IsTmpObj(res2)) {
6962 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6963 } else {
6964 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6966 }
6967 if (SWIG_IsTmpObj(res3)) {
6968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6969 } else {
6970 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6972 }
6973 return resultobj;
6974 fail:
6975 return NULL;
6976 }
6977
6978
6979 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6980 PyObject *resultobj = 0;
6981 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6982 int *arg2 = (int *) 0 ;
6983 int *arg3 = (int *) 0 ;
6984 void *argp1 = 0 ;
6985 int res1 = 0 ;
6986 int temp2 ;
6987 int res2 = SWIG_TMPOBJ ;
6988 int temp3 ;
6989 int res3 = SWIG_TMPOBJ ;
6990 PyObject *swig_obj[1] ;
6991
6992 arg2 = &temp2;
6993 arg3 = &temp3;
6994 if (!args) SWIG_fail;
6995 swig_obj[0] = args;
6996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6997 if (!SWIG_IsOK(res1)) {
6998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6999 }
7000 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 resultobj = SWIG_Py_Void();
7008 if (SWIG_IsTmpObj(res2)) {
7009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7010 } else {
7011 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7013 }
7014 if (SWIG_IsTmpObj(res3)) {
7015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7016 } else {
7017 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7019 }
7020 return resultobj;
7021 fail:
7022 return NULL;
7023 }
7024
7025
7026 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7027 PyObject *resultobj = 0;
7028 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7029 bool result;
7030 void *argp1 = 0 ;
7031 int res1 = 0 ;
7032 PyObject *swig_obj[1] ;
7033
7034 if (!args) SWIG_fail;
7035 swig_obj[0] = args;
7036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7037 if (!SWIG_IsOK(res1)) {
7038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7039 }
7040 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7041 {
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 {
7048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7049 }
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj = 0;
7058 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7059 wxGrid *arg2 = (wxGrid *) 0 ;
7060 int arg3 ;
7061 int arg4 ;
7062 wxGridCellRenderer *result = 0 ;
7063 void *argp1 = 0 ;
7064 int res1 = 0 ;
7065 void *argp2 = 0 ;
7066 int res2 = 0 ;
7067 int val3 ;
7068 int ecode3 = 0 ;
7069 int val4 ;
7070 int ecode4 = 0 ;
7071 PyObject * obj0 = 0 ;
7072 PyObject * obj1 = 0 ;
7073 PyObject * obj2 = 0 ;
7074 PyObject * obj3 = 0 ;
7075 char * kwnames[] = {
7076 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7077 };
7078
7079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7081 if (!SWIG_IsOK(res1)) {
7082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7083 }
7084 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7086 if (!SWIG_IsOK(res2)) {
7087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
7088 }
7089 arg2 = reinterpret_cast< wxGrid * >(argp2);
7090 ecode3 = SWIG_AsVal_int(obj2, &val3);
7091 if (!SWIG_IsOK(ecode3)) {
7092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
7093 }
7094 arg3 = static_cast< int >(val3);
7095 ecode4 = SWIG_AsVal_int(obj3, &val4);
7096 if (!SWIG_IsOK(ecode4)) {
7097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
7098 }
7099 arg4 = static_cast< int >(val4);
7100 {
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
7103 wxPyEndAllowThreads(__tstate);
7104 if (PyErr_Occurred()) SWIG_fail;
7105 }
7106 {
7107 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
7108 }
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7116 PyObject *resultobj = 0;
7117 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7118 wxGrid *arg2 = (wxGrid *) 0 ;
7119 int arg3 ;
7120 int arg4 ;
7121 wxGridCellEditor *result = 0 ;
7122 void *argp1 = 0 ;
7123 int res1 = 0 ;
7124 void *argp2 = 0 ;
7125 int res2 = 0 ;
7126 int val3 ;
7127 int ecode3 = 0 ;
7128 int val4 ;
7129 int ecode4 = 0 ;
7130 PyObject * obj0 = 0 ;
7131 PyObject * obj1 = 0 ;
7132 PyObject * obj2 = 0 ;
7133 PyObject * obj3 = 0 ;
7134 char * kwnames[] = {
7135 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
7136 };
7137
7138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7140 if (!SWIG_IsOK(res1)) {
7141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7142 }
7143 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7145 if (!SWIG_IsOK(res2)) {
7146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
7147 }
7148 arg2 = reinterpret_cast< wxGrid * >(argp2);
7149 ecode3 = SWIG_AsVal_int(obj2, &val3);
7150 if (!SWIG_IsOK(ecode3)) {
7151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
7152 }
7153 arg3 = static_cast< int >(val3);
7154 ecode4 = SWIG_AsVal_int(obj3, &val4);
7155 if (!SWIG_IsOK(ecode4)) {
7156 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
7157 }
7158 arg4 = static_cast< int >(val4);
7159 {
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 {
7166 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
7167 }
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7175 PyObject *resultobj = 0;
7176 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7177 bool result;
7178 void *argp1 = 0 ;
7179 int res1 = 0 ;
7180 PyObject *swig_obj[1] ;
7181
7182 if (!args) SWIG_fail;
7183 swig_obj[0] = args;
7184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7185 if (!SWIG_IsOK(res1)) {
7186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
7187 }
7188 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 {
7196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7197 }
7198 return resultobj;
7199 fail:
7200 return NULL;
7201 }
7202
7203
7204 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7205 PyObject *resultobj = 0;
7206 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7207 wxGridCellAttr::wxAttrKind result;
7208 void *argp1 = 0 ;
7209 int res1 = 0 ;
7210 PyObject *swig_obj[1] ;
7211
7212 if (!args) SWIG_fail;
7213 swig_obj[0] = args;
7214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7215 if (!SWIG_IsOK(res1)) {
7216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7217 }
7218 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7219 {
7220 PyThreadState* __tstate = wxPyBeginAllowThreads();
7221 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
7222 wxPyEndAllowThreads(__tstate);
7223 if (PyErr_Occurred()) SWIG_fail;
7224 }
7225 resultobj = SWIG_From_int(static_cast< int >(result));
7226 return resultobj;
7227 fail:
7228 return NULL;
7229 }
7230
7231
7232 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7233 PyObject *resultobj = 0;
7234 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
7235 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7236 void *argp1 = 0 ;
7237 int res1 = 0 ;
7238 void *argp2 = 0 ;
7239 int res2 = 0 ;
7240 PyObject * obj0 = 0 ;
7241 PyObject * obj1 = 0 ;
7242 char * kwnames[] = {
7243 (char *) "self",(char *) "defAttr", NULL
7244 };
7245
7246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
7247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7248 if (!SWIG_IsOK(res1)) {
7249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
7250 }
7251 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
7252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7253 if (!SWIG_IsOK(res2)) {
7254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7255 }
7256 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7257 {
7258 PyThreadState* __tstate = wxPyBeginAllowThreads();
7259 (arg1)->SetDefAttr(arg2);
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 resultobj = SWIG_Py_Void();
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7271 PyObject *obj;
7272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7273 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7274 return SWIG_Py_Void();
7275 }
7276
7277 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7278 return SWIG_Python_InitShadowInstance(args);
7279 }
7280
7281 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7282 PyObject *resultobj = 0;
7283 wxGridCellAttrProvider *result = 0 ;
7284
7285 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7286 {
7287 PyThreadState* __tstate = wxPyBeginAllowThreads();
7288 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7289 wxPyEndAllowThreads(__tstate);
7290 if (PyErr_Occurred()) SWIG_fail;
7291 }
7292 {
7293 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7294 }
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj = 0;
7303 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7304 PyObject *arg2 = (PyObject *) 0 ;
7305 void *argp1 = 0 ;
7306 int res1 = 0 ;
7307 PyObject * obj0 = 0 ;
7308 PyObject * obj1 = 0 ;
7309 char * kwnames[] = {
7310 (char *) "self",(char *) "_self", NULL
7311 };
7312
7313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7315 if (!SWIG_IsOK(res1)) {
7316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7317 }
7318 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7319 arg2 = obj1;
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 resultobj = SWIG_Py_Void();
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj = 0;
7335 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7336 int arg2 ;
7337 int arg3 ;
7338 wxGridCellAttr::wxAttrKind arg4 ;
7339 wxGridCellAttr *result = 0 ;
7340 void *argp1 = 0 ;
7341 int res1 = 0 ;
7342 int val2 ;
7343 int ecode2 = 0 ;
7344 int val3 ;
7345 int ecode3 = 0 ;
7346 int val4 ;
7347 int ecode4 = 0 ;
7348 PyObject * obj0 = 0 ;
7349 PyObject * obj1 = 0 ;
7350 PyObject * obj2 = 0 ;
7351 PyObject * obj3 = 0 ;
7352 char * kwnames[] = {
7353 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7354 };
7355
7356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7358 if (!SWIG_IsOK(res1)) {
7359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7360 }
7361 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7362 ecode2 = SWIG_AsVal_int(obj1, &val2);
7363 if (!SWIG_IsOK(ecode2)) {
7364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7365 }
7366 arg2 = static_cast< int >(val2);
7367 ecode3 = SWIG_AsVal_int(obj2, &val3);
7368 if (!SWIG_IsOK(ecode3)) {
7369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7370 }
7371 arg3 = static_cast< int >(val3);
7372 ecode4 = SWIG_AsVal_int(obj3, &val4);
7373 if (!SWIG_IsOK(ecode4)) {
7374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7375 }
7376 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7377 {
7378 PyThreadState* __tstate = wxPyBeginAllowThreads();
7379 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7380 wxPyEndAllowThreads(__tstate);
7381 if (PyErr_Occurred()) SWIG_fail;
7382 }
7383 {
7384 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7385 }
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj = 0;
7394 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7395 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7396 int arg3 ;
7397 int arg4 ;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 void *argp2 = 0 ;
7401 int res2 = 0 ;
7402 int val3 ;
7403 int ecode3 = 0 ;
7404 int val4 ;
7405 int ecode4 = 0 ;
7406 PyObject * obj0 = 0 ;
7407 PyObject * obj1 = 0 ;
7408 PyObject * obj2 = 0 ;
7409 PyObject * obj3 = 0 ;
7410 char * kwnames[] = {
7411 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7412 };
7413
7414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7416 if (!SWIG_IsOK(res1)) {
7417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7418 }
7419 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7421 if (!SWIG_IsOK(res2)) {
7422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7423 }
7424 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7425 ecode3 = SWIG_AsVal_int(obj2, &val3);
7426 if (!SWIG_IsOK(ecode3)) {
7427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7428 }
7429 arg3 = static_cast< int >(val3);
7430 ecode4 = SWIG_AsVal_int(obj3, &val4);
7431 if (!SWIG_IsOK(ecode4)) {
7432 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7433 }
7434 arg4 = static_cast< int >(val4);
7435 {
7436 PyThreadState* __tstate = wxPyBeginAllowThreads();
7437 (arg1)->SetAttr(arg2,arg3,arg4);
7438 wxPyEndAllowThreads(__tstate);
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 resultobj = SWIG_Py_Void();
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7451 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7452 int arg3 ;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 void *argp2 = 0 ;
7456 int res2 = 0 ;
7457 int val3 ;
7458 int ecode3 = 0 ;
7459 PyObject * obj0 = 0 ;
7460 PyObject * obj1 = 0 ;
7461 PyObject * obj2 = 0 ;
7462 char * kwnames[] = {
7463 (char *) "self",(char *) "attr",(char *) "row", NULL
7464 };
7465
7466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7468 if (!SWIG_IsOK(res1)) {
7469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7470 }
7471 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7473 if (!SWIG_IsOK(res2)) {
7474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7475 }
7476 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7477 ecode3 = SWIG_AsVal_int(obj2, &val3);
7478 if (!SWIG_IsOK(ecode3)) {
7479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7480 }
7481 arg3 = static_cast< int >(val3);
7482 {
7483 PyThreadState* __tstate = wxPyBeginAllowThreads();
7484 (arg1)->SetRowAttr(arg2,arg3);
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 resultobj = SWIG_Py_Void();
7489 return resultobj;
7490 fail:
7491 return NULL;
7492 }
7493
7494
7495 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7496 PyObject *resultobj = 0;
7497 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7498 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7499 int arg3 ;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 void *argp2 = 0 ;
7503 int res2 = 0 ;
7504 int val3 ;
7505 int ecode3 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 PyObject * obj2 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "attr",(char *) "col", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7517 }
7518 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7520 if (!SWIG_IsOK(res2)) {
7521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7522 }
7523 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7524 ecode3 = SWIG_AsVal_int(obj2, &val3);
7525 if (!SWIG_IsOK(ecode3)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7527 }
7528 arg3 = static_cast< int >(val3);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 (arg1)->SetColAttr(arg2,arg3);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 resultobj = SWIG_Py_Void();
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7543 PyObject *resultobj = 0;
7544 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7545 size_t arg2 ;
7546 int arg3 ;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 size_t val2 ;
7550 int ecode2 = 0 ;
7551 int val3 ;
7552 int ecode3 = 0 ;
7553 PyObject * obj0 = 0 ;
7554 PyObject * obj1 = 0 ;
7555 PyObject * obj2 = 0 ;
7556 char * kwnames[] = {
7557 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7558 };
7559
7560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7562 if (!SWIG_IsOK(res1)) {
7563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7564 }
7565 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7566 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7567 if (!SWIG_IsOK(ecode2)) {
7568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7569 }
7570 arg2 = static_cast< size_t >(val2);
7571 ecode3 = SWIG_AsVal_int(obj2, &val3);
7572 if (!SWIG_IsOK(ecode3)) {
7573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7574 }
7575 arg3 = static_cast< int >(val3);
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 (arg1)->UpdateAttrRows(arg2,arg3);
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_Py_Void();
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj = 0;
7591 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7592 size_t arg2 ;
7593 int arg3 ;
7594 void *argp1 = 0 ;
7595 int res1 = 0 ;
7596 size_t val2 ;
7597 int ecode2 = 0 ;
7598 int val3 ;
7599 int ecode3 = 0 ;
7600 PyObject * obj0 = 0 ;
7601 PyObject * obj1 = 0 ;
7602 PyObject * obj2 = 0 ;
7603 char * kwnames[] = {
7604 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7605 };
7606
7607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7609 if (!SWIG_IsOK(res1)) {
7610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7611 }
7612 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7613 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7614 if (!SWIG_IsOK(ecode2)) {
7615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7616 }
7617 arg2 = static_cast< size_t >(val2);
7618 ecode3 = SWIG_AsVal_int(obj2, &val3);
7619 if (!SWIG_IsOK(ecode3)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7621 }
7622 arg3 = static_cast< int >(val3);
7623 {
7624 PyThreadState* __tstate = wxPyBeginAllowThreads();
7625 (arg1)->UpdateAttrCols(arg2,arg3);
7626 wxPyEndAllowThreads(__tstate);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 resultobj = SWIG_Py_Void();
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *obj;
7638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7639 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7640 return SWIG_Py_Void();
7641 }
7642
7643 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7644 return SWIG_Python_InitShadowInstance(args);
7645 }
7646
7647 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7648 PyObject *resultobj = 0;
7649 wxPyGridCellAttrProvider *result = 0 ;
7650
7651 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7652 {
7653 PyThreadState* __tstate = wxPyBeginAllowThreads();
7654 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7655 wxPyEndAllowThreads(__tstate);
7656 if (PyErr_Occurred()) SWIG_fail;
7657 }
7658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7659 return resultobj;
7660 fail:
7661 return NULL;
7662 }
7663
7664
7665 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7666 PyObject *resultobj = 0;
7667 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7668 PyObject *arg2 = (PyObject *) 0 ;
7669 PyObject *arg3 = (PyObject *) 0 ;
7670 void *argp1 = 0 ;
7671 int res1 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 PyObject * obj2 = 0 ;
7675 char * kwnames[] = {
7676 (char *) "self",(char *) "self",(char *) "_class", NULL
7677 };
7678
7679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7683 }
7684 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7685 arg2 = obj1;
7686 arg3 = obj2;
7687 {
7688 PyThreadState* __tstate = wxPyBeginAllowThreads();
7689 (arg1)->_setCallbackInfo(arg2,arg3);
7690 wxPyEndAllowThreads(__tstate);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 resultobj = SWIG_Py_Void();
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7701 PyObject *resultobj = 0;
7702 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7703 int arg2 ;
7704 int arg3 ;
7705 wxGridCellAttr::wxAttrKind arg4 ;
7706 wxGridCellAttr *result = 0 ;
7707 void *argp1 = 0 ;
7708 int res1 = 0 ;
7709 int val2 ;
7710 int ecode2 = 0 ;
7711 int val3 ;
7712 int ecode3 = 0 ;
7713 int val4 ;
7714 int ecode4 = 0 ;
7715 PyObject * obj0 = 0 ;
7716 PyObject * obj1 = 0 ;
7717 PyObject * obj2 = 0 ;
7718 PyObject * obj3 = 0 ;
7719 char * kwnames[] = {
7720 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7721 };
7722
7723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7725 if (!SWIG_IsOK(res1)) {
7726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7727 }
7728 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7729 ecode2 = SWIG_AsVal_int(obj1, &val2);
7730 if (!SWIG_IsOK(ecode2)) {
7731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7732 }
7733 arg2 = static_cast< int >(val2);
7734 ecode3 = SWIG_AsVal_int(obj2, &val3);
7735 if (!SWIG_IsOK(ecode3)) {
7736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7737 }
7738 arg3 = static_cast< int >(val3);
7739 ecode4 = SWIG_AsVal_int(obj3, &val4);
7740 if (!SWIG_IsOK(ecode4)) {
7741 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7742 }
7743 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7744 {
7745 PyThreadState* __tstate = wxPyBeginAllowThreads();
7746 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7747 wxPyEndAllowThreads(__tstate);
7748 if (PyErr_Occurred()) SWIG_fail;
7749 }
7750 {
7751 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7752 }
7753 return resultobj;
7754 fail:
7755 return NULL;
7756 }
7757
7758
7759 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7760 PyObject *resultobj = 0;
7761 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7762 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7763 int arg3 ;
7764 int arg4 ;
7765 void *argp1 = 0 ;
7766 int res1 = 0 ;
7767 void *argp2 = 0 ;
7768 int res2 = 0 ;
7769 int val3 ;
7770 int ecode3 = 0 ;
7771 int val4 ;
7772 int ecode4 = 0 ;
7773 PyObject * obj0 = 0 ;
7774 PyObject * obj1 = 0 ;
7775 PyObject * obj2 = 0 ;
7776 PyObject * obj3 = 0 ;
7777 char * kwnames[] = {
7778 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7779 };
7780
7781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7783 if (!SWIG_IsOK(res1)) {
7784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7785 }
7786 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7788 if (!SWIG_IsOK(res2)) {
7789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7790 }
7791 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7792 ecode3 = SWIG_AsVal_int(obj2, &val3);
7793 if (!SWIG_IsOK(ecode3)) {
7794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7795 }
7796 arg3 = static_cast< int >(val3);
7797 ecode4 = SWIG_AsVal_int(obj3, &val4);
7798 if (!SWIG_IsOK(ecode4)) {
7799 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7800 }
7801 arg4 = static_cast< int >(val4);
7802 {
7803 PyThreadState* __tstate = wxPyBeginAllowThreads();
7804 (arg1)->SetAttr(arg2,arg3,arg4);
7805 wxPyEndAllowThreads(__tstate);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 resultobj = SWIG_Py_Void();
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7816 PyObject *resultobj = 0;
7817 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7818 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7819 int arg3 ;
7820 void *argp1 = 0 ;
7821 int res1 = 0 ;
7822 void *argp2 = 0 ;
7823 int res2 = 0 ;
7824 int val3 ;
7825 int ecode3 = 0 ;
7826 PyObject * obj0 = 0 ;
7827 PyObject * obj1 = 0 ;
7828 PyObject * obj2 = 0 ;
7829 char * kwnames[] = {
7830 (char *) "self",(char *) "attr",(char *) "row", NULL
7831 };
7832
7833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7835 if (!SWIG_IsOK(res1)) {
7836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7837 }
7838 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7840 if (!SWIG_IsOK(res2)) {
7841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7842 }
7843 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7844 ecode3 = SWIG_AsVal_int(obj2, &val3);
7845 if (!SWIG_IsOK(ecode3)) {
7846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7847 }
7848 arg3 = static_cast< int >(val3);
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 (arg1)->SetRowAttr(arg2,arg3);
7852 wxPyEndAllowThreads(__tstate);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_Py_Void();
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7863 PyObject *resultobj = 0;
7864 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7865 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7866 int arg3 ;
7867 void *argp1 = 0 ;
7868 int res1 = 0 ;
7869 void *argp2 = 0 ;
7870 int res2 = 0 ;
7871 int val3 ;
7872 int ecode3 = 0 ;
7873 PyObject * obj0 = 0 ;
7874 PyObject * obj1 = 0 ;
7875 PyObject * obj2 = 0 ;
7876 char * kwnames[] = {
7877 (char *) "self",(char *) "attr",(char *) "col", NULL
7878 };
7879
7880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7882 if (!SWIG_IsOK(res1)) {
7883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7884 }
7885 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7886 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7887 if (!SWIG_IsOK(res2)) {
7888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7889 }
7890 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7891 ecode3 = SWIG_AsVal_int(obj2, &val3);
7892 if (!SWIG_IsOK(ecode3)) {
7893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7894 }
7895 arg3 = static_cast< int >(val3);
7896 {
7897 PyThreadState* __tstate = wxPyBeginAllowThreads();
7898 (arg1)->SetColAttr(arg2,arg3);
7899 wxPyEndAllowThreads(__tstate);
7900 if (PyErr_Occurred()) SWIG_fail;
7901 }
7902 resultobj = SWIG_Py_Void();
7903 return resultobj;
7904 fail:
7905 return NULL;
7906 }
7907
7908
7909 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7910 PyObject *obj;
7911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7912 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7913 return SWIG_Py_Void();
7914 }
7915
7916 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7917 return SWIG_Python_InitShadowInstance(args);
7918 }
7919
7920 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7921 PyObject *resultobj = 0;
7922 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7923 void *argp1 = 0 ;
7924 int res1 = 0 ;
7925 PyObject *swig_obj[1] ;
7926
7927 if (!args) SWIG_fail;
7928 swig_obj[0] = args;
7929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7930 if (!SWIG_IsOK(res1)) {
7931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7932 }
7933 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7934 {
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 delete arg1;
7937
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = SWIG_Py_Void();
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj = 0;
7950 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7951 PyObject *arg2 = (PyObject *) 0 ;
7952 void *argp1 = 0 ;
7953 int res1 = 0 ;
7954 PyObject * obj0 = 0 ;
7955 PyObject * obj1 = 0 ;
7956 char * kwnames[] = {
7957 (char *) "self",(char *) "_self", NULL
7958 };
7959
7960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7962 if (!SWIG_IsOK(res1)) {
7963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7964 }
7965 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7966 arg2 = obj1;
7967 {
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 wxGridTableBase__setOORInfo(arg1,arg2);
7970 wxPyEndAllowThreads(__tstate);
7971 if (PyErr_Occurred()) SWIG_fail;
7972 }
7973 resultobj = SWIG_Py_Void();
7974 return resultobj;
7975 fail:
7976 return NULL;
7977 }
7978
7979
7980 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7981 PyObject *resultobj = 0;
7982 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7983 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7984 void *argp1 = 0 ;
7985 int res1 = 0 ;
7986 void *argp2 = 0 ;
7987 int res2 = 0 ;
7988 PyObject * obj0 = 0 ;
7989 PyObject * obj1 = 0 ;
7990 char * kwnames[] = {
7991 (char *) "self",(char *) "attrProvider", NULL
7992 };
7993
7994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7996 if (!SWIG_IsOK(res1)) {
7997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7998 }
7999 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8000 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
8001 if (!SWIG_IsOK(res2)) {
8002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
8003 }
8004 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 (arg1)->SetAttrProvider(arg2);
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 resultobj = SWIG_Py_Void();
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8019 PyObject *resultobj = 0;
8020 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8021 wxGridCellAttrProvider *result = 0 ;
8022 void *argp1 = 0 ;
8023 int res1 = 0 ;
8024 PyObject *swig_obj[1] ;
8025
8026 if (!args) SWIG_fail;
8027 swig_obj[0] = args;
8028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8029 if (!SWIG_IsOK(res1)) {
8030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8031 }
8032 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 {
8040 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
8041 }
8042 return resultobj;
8043 fail:
8044 return NULL;
8045 }
8046
8047
8048 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8049 PyObject *resultobj = 0;
8050 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8051 wxGrid *arg2 = (wxGrid *) 0 ;
8052 void *argp1 = 0 ;
8053 int res1 = 0 ;
8054 void *argp2 = 0 ;
8055 int res2 = 0 ;
8056 PyObject * obj0 = 0 ;
8057 PyObject * obj1 = 0 ;
8058 char * kwnames[] = {
8059 (char *) "self",(char *) "grid", NULL
8060 };
8061
8062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
8063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8066 }
8067 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
8069 if (!SWIG_IsOK(res2)) {
8070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
8071 }
8072 arg2 = reinterpret_cast< wxGrid * >(argp2);
8073 {
8074 PyThreadState* __tstate = wxPyBeginAllowThreads();
8075 (arg1)->SetView(arg2);
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 resultobj = SWIG_Py_Void();
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8087 PyObject *resultobj = 0;
8088 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8089 wxGrid *result = 0 ;
8090 void *argp1 = 0 ;
8091 int res1 = 0 ;
8092 PyObject *swig_obj[1] ;
8093
8094 if (!args) SWIG_fail;
8095 swig_obj[0] = args;
8096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8097 if (!SWIG_IsOK(res1)) {
8098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
8099 }
8100 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8101 {
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 resultobj = wxPyMake_wxObject(result, (bool)0);
8109 }
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8117 PyObject *resultobj = 0;
8118 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8119 int result;
8120 void *argp1 = 0 ;
8121 int res1 = 0 ;
8122 PyObject *swig_obj[1] ;
8123
8124 if (!args) SWIG_fail;
8125 swig_obj[0] = args;
8126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8127 if (!SWIG_IsOK(res1)) {
8128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8129 }
8130 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 result = (int)(arg1)->GetNumberRows();
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_From_int(static_cast< int >(result));
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8145 PyObject *resultobj = 0;
8146 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8147 int result;
8148 void *argp1 = 0 ;
8149 int res1 = 0 ;
8150 PyObject *swig_obj[1] ;
8151
8152 if (!args) SWIG_fail;
8153 swig_obj[0] = args;
8154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8155 if (!SWIG_IsOK(res1)) {
8156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8157 }
8158 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (int)(arg1)->GetNumberCols();
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_From_int(static_cast< int >(result));
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8173 PyObject *resultobj = 0;
8174 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8175 int arg2 ;
8176 int arg3 ;
8177 bool result;
8178 void *argp1 = 0 ;
8179 int res1 = 0 ;
8180 int val2 ;
8181 int ecode2 = 0 ;
8182 int val3 ;
8183 int ecode3 = 0 ;
8184 PyObject * obj0 = 0 ;
8185 PyObject * obj1 = 0 ;
8186 PyObject * obj2 = 0 ;
8187 char * kwnames[] = {
8188 (char *) "self",(char *) "row",(char *) "col", NULL
8189 };
8190
8191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8193 if (!SWIG_IsOK(res1)) {
8194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8195 }
8196 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8197 ecode2 = SWIG_AsVal_int(obj1, &val2);
8198 if (!SWIG_IsOK(ecode2)) {
8199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
8200 }
8201 arg2 = static_cast< int >(val2);
8202 ecode3 = SWIG_AsVal_int(obj2, &val3);
8203 if (!SWIG_IsOK(ecode3)) {
8204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
8205 }
8206 arg3 = static_cast< int >(val3);
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 {
8214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8215 }
8216 return resultobj;
8217 fail:
8218 return NULL;
8219 }
8220
8221
8222 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj = 0;
8224 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8225 int arg2 ;
8226 int arg3 ;
8227 wxString result;
8228 void *argp1 = 0 ;
8229 int res1 = 0 ;
8230 int val2 ;
8231 int ecode2 = 0 ;
8232 int val3 ;
8233 int ecode3 = 0 ;
8234 PyObject * obj0 = 0 ;
8235 PyObject * obj1 = 0 ;
8236 PyObject * obj2 = 0 ;
8237 char * kwnames[] = {
8238 (char *) "self",(char *) "row",(char *) "col", NULL
8239 };
8240
8241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8243 if (!SWIG_IsOK(res1)) {
8244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8245 }
8246 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8247 ecode2 = SWIG_AsVal_int(obj1, &val2);
8248 if (!SWIG_IsOK(ecode2)) {
8249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
8250 }
8251 arg2 = static_cast< int >(val2);
8252 ecode3 = SWIG_AsVal_int(obj2, &val3);
8253 if (!SWIG_IsOK(ecode3)) {
8254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
8255 }
8256 arg3 = static_cast< int >(val3);
8257 {
8258 PyThreadState* __tstate = wxPyBeginAllowThreads();
8259 result = (arg1)->GetValue(arg2,arg3);
8260 wxPyEndAllowThreads(__tstate);
8261 if (PyErr_Occurred()) SWIG_fail;
8262 }
8263 {
8264 #if wxUSE_UNICODE
8265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8266 #else
8267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8268 #endif
8269 }
8270 return resultobj;
8271 fail:
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj = 0;
8278 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8279 int arg2 ;
8280 int arg3 ;
8281 wxString *arg4 = 0 ;
8282 void *argp1 = 0 ;
8283 int res1 = 0 ;
8284 int val2 ;
8285 int ecode2 = 0 ;
8286 int val3 ;
8287 int ecode3 = 0 ;
8288 bool temp4 = false ;
8289 PyObject * obj0 = 0 ;
8290 PyObject * obj1 = 0 ;
8291 PyObject * obj2 = 0 ;
8292 PyObject * obj3 = 0 ;
8293 char * kwnames[] = {
8294 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8295 };
8296
8297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8299 if (!SWIG_IsOK(res1)) {
8300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8301 }
8302 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8303 ecode2 = SWIG_AsVal_int(obj1, &val2);
8304 if (!SWIG_IsOK(ecode2)) {
8305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8306 }
8307 arg2 = static_cast< int >(val2);
8308 ecode3 = SWIG_AsVal_int(obj2, &val3);
8309 if (!SWIG_IsOK(ecode3)) {
8310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8311 }
8312 arg3 = static_cast< int >(val3);
8313 {
8314 arg4 = wxString_in_helper(obj3);
8315 if (arg4 == NULL) SWIG_fail;
8316 temp4 = true;
8317 }
8318 {
8319 PyThreadState* __tstate = wxPyBeginAllowThreads();
8320 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8321 wxPyEndAllowThreads(__tstate);
8322 if (PyErr_Occurred()) SWIG_fail;
8323 }
8324 resultobj = SWIG_Py_Void();
8325 {
8326 if (temp4)
8327 delete arg4;
8328 }
8329 return resultobj;
8330 fail:
8331 {
8332 if (temp4)
8333 delete arg4;
8334 }
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8342 int arg2 ;
8343 int arg3 ;
8344 wxString result;
8345 void *argp1 = 0 ;
8346 int res1 = 0 ;
8347 int val2 ;
8348 int ecode2 = 0 ;
8349 int val3 ;
8350 int ecode3 = 0 ;
8351 PyObject * obj0 = 0 ;
8352 PyObject * obj1 = 0 ;
8353 PyObject * obj2 = 0 ;
8354 char * kwnames[] = {
8355 (char *) "self",(char *) "row",(char *) "col", NULL
8356 };
8357
8358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8360 if (!SWIG_IsOK(res1)) {
8361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8362 }
8363 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8364 ecode2 = SWIG_AsVal_int(obj1, &val2);
8365 if (!SWIG_IsOK(ecode2)) {
8366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8367 }
8368 arg2 = static_cast< int >(val2);
8369 ecode3 = SWIG_AsVal_int(obj2, &val3);
8370 if (!SWIG_IsOK(ecode3)) {
8371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8372 }
8373 arg3 = static_cast< int >(val3);
8374 {
8375 PyThreadState* __tstate = wxPyBeginAllowThreads();
8376 result = (arg1)->GetTypeName(arg2,arg3);
8377 wxPyEndAllowThreads(__tstate);
8378 if (PyErr_Occurred()) SWIG_fail;
8379 }
8380 {
8381 #if wxUSE_UNICODE
8382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8383 #else
8384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8385 #endif
8386 }
8387 return resultobj;
8388 fail:
8389 return NULL;
8390 }
8391
8392
8393 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj = 0;
8395 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8396 int arg2 ;
8397 int arg3 ;
8398 wxString *arg4 = 0 ;
8399 bool result;
8400 void *argp1 = 0 ;
8401 int res1 = 0 ;
8402 int val2 ;
8403 int ecode2 = 0 ;
8404 int val3 ;
8405 int ecode3 = 0 ;
8406 bool temp4 = false ;
8407 PyObject * obj0 = 0 ;
8408 PyObject * obj1 = 0 ;
8409 PyObject * obj2 = 0 ;
8410 PyObject * obj3 = 0 ;
8411 char * kwnames[] = {
8412 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8413 };
8414
8415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8417 if (!SWIG_IsOK(res1)) {
8418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8419 }
8420 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8421 ecode2 = SWIG_AsVal_int(obj1, &val2);
8422 if (!SWIG_IsOK(ecode2)) {
8423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8424 }
8425 arg2 = static_cast< int >(val2);
8426 ecode3 = SWIG_AsVal_int(obj2, &val3);
8427 if (!SWIG_IsOK(ecode3)) {
8428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8429 }
8430 arg3 = static_cast< int >(val3);
8431 {
8432 arg4 = wxString_in_helper(obj3);
8433 if (arg4 == NULL) SWIG_fail;
8434 temp4 = true;
8435 }
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8439 wxPyEndAllowThreads(__tstate);
8440 if (PyErr_Occurred()) SWIG_fail;
8441 }
8442 {
8443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8444 }
8445 {
8446 if (temp4)
8447 delete arg4;
8448 }
8449 return resultobj;
8450 fail:
8451 {
8452 if (temp4)
8453 delete arg4;
8454 }
8455 return NULL;
8456 }
8457
8458
8459 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8460 PyObject *resultobj = 0;
8461 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8462 int arg2 ;
8463 int arg3 ;
8464 wxString *arg4 = 0 ;
8465 bool result;
8466 void *argp1 = 0 ;
8467 int res1 = 0 ;
8468 int val2 ;
8469 int ecode2 = 0 ;
8470 int val3 ;
8471 int ecode3 = 0 ;
8472 bool temp4 = false ;
8473 PyObject * obj0 = 0 ;
8474 PyObject * obj1 = 0 ;
8475 PyObject * obj2 = 0 ;
8476 PyObject * obj3 = 0 ;
8477 char * kwnames[] = {
8478 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8479 };
8480
8481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8485 }
8486 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8487 ecode2 = SWIG_AsVal_int(obj1, &val2);
8488 if (!SWIG_IsOK(ecode2)) {
8489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8490 }
8491 arg2 = static_cast< int >(val2);
8492 ecode3 = SWIG_AsVal_int(obj2, &val3);
8493 if (!SWIG_IsOK(ecode3)) {
8494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8495 }
8496 arg3 = static_cast< int >(val3);
8497 {
8498 arg4 = wxString_in_helper(obj3);
8499 if (arg4 == NULL) SWIG_fail;
8500 temp4 = true;
8501 }
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 {
8509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8510 }
8511 {
8512 if (temp4)
8513 delete arg4;
8514 }
8515 return resultobj;
8516 fail:
8517 {
8518 if (temp4)
8519 delete arg4;
8520 }
8521 return NULL;
8522 }
8523
8524
8525 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8526 PyObject *resultobj = 0;
8527 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8528 int arg2 ;
8529 int arg3 ;
8530 long result;
8531 void *argp1 = 0 ;
8532 int res1 = 0 ;
8533 int val2 ;
8534 int ecode2 = 0 ;
8535 int val3 ;
8536 int ecode3 = 0 ;
8537 PyObject * obj0 = 0 ;
8538 PyObject * obj1 = 0 ;
8539 PyObject * obj2 = 0 ;
8540 char * kwnames[] = {
8541 (char *) "self",(char *) "row",(char *) "col", NULL
8542 };
8543
8544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8546 if (!SWIG_IsOK(res1)) {
8547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8548 }
8549 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8550 ecode2 = SWIG_AsVal_int(obj1, &val2);
8551 if (!SWIG_IsOK(ecode2)) {
8552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8553 }
8554 arg2 = static_cast< int >(val2);
8555 ecode3 = SWIG_AsVal_int(obj2, &val3);
8556 if (!SWIG_IsOK(ecode3)) {
8557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8558 }
8559 arg3 = static_cast< int >(val3);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_From_long(static_cast< long >(result));
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj = 0;
8575 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8576 int arg2 ;
8577 int arg3 ;
8578 double result;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 int val2 ;
8582 int ecode2 = 0 ;
8583 int val3 ;
8584 int ecode3 = 0 ;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 PyObject * obj2 = 0 ;
8588 char * kwnames[] = {
8589 (char *) "self",(char *) "row",(char *) "col", NULL
8590 };
8591
8592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8594 if (!SWIG_IsOK(res1)) {
8595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8596 }
8597 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8598 ecode2 = SWIG_AsVal_int(obj1, &val2);
8599 if (!SWIG_IsOK(ecode2)) {
8600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8601 }
8602 arg2 = static_cast< int >(val2);
8603 ecode3 = SWIG_AsVal_int(obj2, &val3);
8604 if (!SWIG_IsOK(ecode3)) {
8605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8606 }
8607 arg3 = static_cast< int >(val3);
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8611 wxPyEndAllowThreads(__tstate);
8612 if (PyErr_Occurred()) SWIG_fail;
8613 }
8614 resultobj = SWIG_From_double(static_cast< double >(result));
8615 return resultobj;
8616 fail:
8617 return NULL;
8618 }
8619
8620
8621 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8622 PyObject *resultobj = 0;
8623 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8624 int arg2 ;
8625 int arg3 ;
8626 bool result;
8627 void *argp1 = 0 ;
8628 int res1 = 0 ;
8629 int val2 ;
8630 int ecode2 = 0 ;
8631 int val3 ;
8632 int ecode3 = 0 ;
8633 PyObject * obj0 = 0 ;
8634 PyObject * obj1 = 0 ;
8635 PyObject * obj2 = 0 ;
8636 char * kwnames[] = {
8637 (char *) "self",(char *) "row",(char *) "col", NULL
8638 };
8639
8640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8642 if (!SWIG_IsOK(res1)) {
8643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8644 }
8645 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8646 ecode2 = SWIG_AsVal_int(obj1, &val2);
8647 if (!SWIG_IsOK(ecode2)) {
8648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8649 }
8650 arg2 = static_cast< int >(val2);
8651 ecode3 = SWIG_AsVal_int(obj2, &val3);
8652 if (!SWIG_IsOK(ecode3)) {
8653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8654 }
8655 arg3 = static_cast< int >(val3);
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8659 wxPyEndAllowThreads(__tstate);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 {
8663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8664 }
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj = 0;
8673 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8674 int arg2 ;
8675 int arg3 ;
8676 long arg4 ;
8677 void *argp1 = 0 ;
8678 int res1 = 0 ;
8679 int val2 ;
8680 int ecode2 = 0 ;
8681 int val3 ;
8682 int ecode3 = 0 ;
8683 long val4 ;
8684 int ecode4 = 0 ;
8685 PyObject * obj0 = 0 ;
8686 PyObject * obj1 = 0 ;
8687 PyObject * obj2 = 0 ;
8688 PyObject * obj3 = 0 ;
8689 char * kwnames[] = {
8690 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8691 };
8692
8693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8697 }
8698 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8699 ecode2 = SWIG_AsVal_int(obj1, &val2);
8700 if (!SWIG_IsOK(ecode2)) {
8701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8702 }
8703 arg2 = static_cast< int >(val2);
8704 ecode3 = SWIG_AsVal_int(obj2, &val3);
8705 if (!SWIG_IsOK(ecode3)) {
8706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8707 }
8708 arg3 = static_cast< int >(val3);
8709 ecode4 = SWIG_AsVal_long(obj3, &val4);
8710 if (!SWIG_IsOK(ecode4)) {
8711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8712 }
8713 arg4 = static_cast< long >(val4);
8714 {
8715 PyThreadState* __tstate = wxPyBeginAllowThreads();
8716 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8717 wxPyEndAllowThreads(__tstate);
8718 if (PyErr_Occurred()) SWIG_fail;
8719 }
8720 resultobj = SWIG_Py_Void();
8721 return resultobj;
8722 fail:
8723 return NULL;
8724 }
8725
8726
8727 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8728 PyObject *resultobj = 0;
8729 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8730 int arg2 ;
8731 int arg3 ;
8732 double arg4 ;
8733 void *argp1 = 0 ;
8734 int res1 = 0 ;
8735 int val2 ;
8736 int ecode2 = 0 ;
8737 int val3 ;
8738 int ecode3 = 0 ;
8739 double val4 ;
8740 int ecode4 = 0 ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 PyObject * obj2 = 0 ;
8744 PyObject * obj3 = 0 ;
8745 char * kwnames[] = {
8746 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8747 };
8748
8749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8751 if (!SWIG_IsOK(res1)) {
8752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8753 }
8754 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8755 ecode2 = SWIG_AsVal_int(obj1, &val2);
8756 if (!SWIG_IsOK(ecode2)) {
8757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8758 }
8759 arg2 = static_cast< int >(val2);
8760 ecode3 = SWIG_AsVal_int(obj2, &val3);
8761 if (!SWIG_IsOK(ecode3)) {
8762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8763 }
8764 arg3 = static_cast< int >(val3);
8765 ecode4 = SWIG_AsVal_double(obj3, &val4);
8766 if (!SWIG_IsOK(ecode4)) {
8767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8768 }
8769 arg4 = static_cast< double >(val4);
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8773 wxPyEndAllowThreads(__tstate);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 resultobj = SWIG_Py_Void();
8777 return resultobj;
8778 fail:
8779 return NULL;
8780 }
8781
8782
8783 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj = 0;
8785 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8786 int arg2 ;
8787 int arg3 ;
8788 bool arg4 ;
8789 void *argp1 = 0 ;
8790 int res1 = 0 ;
8791 int val2 ;
8792 int ecode2 = 0 ;
8793 int val3 ;
8794 int ecode3 = 0 ;
8795 bool val4 ;
8796 int ecode4 = 0 ;
8797 PyObject * obj0 = 0 ;
8798 PyObject * obj1 = 0 ;
8799 PyObject * obj2 = 0 ;
8800 PyObject * obj3 = 0 ;
8801 char * kwnames[] = {
8802 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8803 };
8804
8805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8807 if (!SWIG_IsOK(res1)) {
8808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8809 }
8810 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8811 ecode2 = SWIG_AsVal_int(obj1, &val2);
8812 if (!SWIG_IsOK(ecode2)) {
8813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8814 }
8815 arg2 = static_cast< int >(val2);
8816 ecode3 = SWIG_AsVal_int(obj2, &val3);
8817 if (!SWIG_IsOK(ecode3)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8819 }
8820 arg3 = static_cast< int >(val3);
8821 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8822 if (!SWIG_IsOK(ecode4)) {
8823 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8824 }
8825 arg4 = static_cast< bool >(val4);
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 resultobj = SWIG_Py_Void();
8833 return resultobj;
8834 fail:
8835 return NULL;
8836 }
8837
8838
8839 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8840 PyObject *resultobj = 0;
8841 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8842 void *argp1 = 0 ;
8843 int res1 = 0 ;
8844 PyObject *swig_obj[1] ;
8845
8846 if (!args) SWIG_fail;
8847 swig_obj[0] = args;
8848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8851 }
8852 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8853 {
8854 PyThreadState* __tstate = wxPyBeginAllowThreads();
8855 (arg1)->Clear();
8856 wxPyEndAllowThreads(__tstate);
8857 if (PyErr_Occurred()) SWIG_fail;
8858 }
8859 resultobj = SWIG_Py_Void();
8860 return resultobj;
8861 fail:
8862 return NULL;
8863 }
8864
8865
8866 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8867 PyObject *resultobj = 0;
8868 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8869 size_t arg2 = (size_t) 0 ;
8870 size_t arg3 = (size_t) 1 ;
8871 bool result;
8872 void *argp1 = 0 ;
8873 int res1 = 0 ;
8874 size_t val2 ;
8875 int ecode2 = 0 ;
8876 size_t val3 ;
8877 int ecode3 = 0 ;
8878 PyObject * obj0 = 0 ;
8879 PyObject * obj1 = 0 ;
8880 PyObject * obj2 = 0 ;
8881 char * kwnames[] = {
8882 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8883 };
8884
8885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8889 }
8890 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8891 if (obj1) {
8892 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8893 if (!SWIG_IsOK(ecode2)) {
8894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8895 }
8896 arg2 = static_cast< size_t >(val2);
8897 }
8898 if (obj2) {
8899 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8900 if (!SWIG_IsOK(ecode3)) {
8901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8902 }
8903 arg3 = static_cast< size_t >(val3);
8904 }
8905 {
8906 PyThreadState* __tstate = wxPyBeginAllowThreads();
8907 result = (bool)(arg1)->InsertRows(arg2,arg3);
8908 wxPyEndAllowThreads(__tstate);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 {
8912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8913 }
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8921 PyObject *resultobj = 0;
8922 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8923 size_t arg2 = (size_t) 1 ;
8924 bool result;
8925 void *argp1 = 0 ;
8926 int res1 = 0 ;
8927 size_t val2 ;
8928 int ecode2 = 0 ;
8929 PyObject * obj0 = 0 ;
8930 PyObject * obj1 = 0 ;
8931 char * kwnames[] = {
8932 (char *) "self",(char *) "numRows", NULL
8933 };
8934
8935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8937 if (!SWIG_IsOK(res1)) {
8938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8939 }
8940 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8941 if (obj1) {
8942 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8943 if (!SWIG_IsOK(ecode2)) {
8944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8945 }
8946 arg2 = static_cast< size_t >(val2);
8947 }
8948 {
8949 PyThreadState* __tstate = wxPyBeginAllowThreads();
8950 result = (bool)(arg1)->AppendRows(arg2);
8951 wxPyEndAllowThreads(__tstate);
8952 if (PyErr_Occurred()) SWIG_fail;
8953 }
8954 {
8955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8956 }
8957 return resultobj;
8958 fail:
8959 return NULL;
8960 }
8961
8962
8963 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj = 0;
8965 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8966 size_t arg2 = (size_t) 0 ;
8967 size_t arg3 = (size_t) 1 ;
8968 bool result;
8969 void *argp1 = 0 ;
8970 int res1 = 0 ;
8971 size_t val2 ;
8972 int ecode2 = 0 ;
8973 size_t val3 ;
8974 int ecode3 = 0 ;
8975 PyObject * obj0 = 0 ;
8976 PyObject * obj1 = 0 ;
8977 PyObject * obj2 = 0 ;
8978 char * kwnames[] = {
8979 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8980 };
8981
8982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8984 if (!SWIG_IsOK(res1)) {
8985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8986 }
8987 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8988 if (obj1) {
8989 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8990 if (!SWIG_IsOK(ecode2)) {
8991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8992 }
8993 arg2 = static_cast< size_t >(val2);
8994 }
8995 if (obj2) {
8996 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8997 if (!SWIG_IsOK(ecode3)) {
8998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8999 }
9000 arg3 = static_cast< size_t >(val3);
9001 }
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 result = (bool)(arg1)->DeleteRows(arg2,arg3);
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 {
9009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9010 }
9011 return resultobj;
9012 fail:
9013 return NULL;
9014 }
9015
9016
9017 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9018 PyObject *resultobj = 0;
9019 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9020 size_t arg2 = (size_t) 0 ;
9021 size_t arg3 = (size_t) 1 ;
9022 bool result;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 size_t val2 ;
9026 int ecode2 = 0 ;
9027 size_t val3 ;
9028 int ecode3 = 0 ;
9029 PyObject * obj0 = 0 ;
9030 PyObject * obj1 = 0 ;
9031 PyObject * obj2 = 0 ;
9032 char * kwnames[] = {
9033 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9034 };
9035
9036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9038 if (!SWIG_IsOK(res1)) {
9039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9040 }
9041 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9042 if (obj1) {
9043 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9044 if (!SWIG_IsOK(ecode2)) {
9045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
9046 }
9047 arg2 = static_cast< size_t >(val2);
9048 }
9049 if (obj2) {
9050 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9051 if (!SWIG_IsOK(ecode3)) {
9052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
9053 }
9054 arg3 = static_cast< size_t >(val3);
9055 }
9056 {
9057 PyThreadState* __tstate = wxPyBeginAllowThreads();
9058 result = (bool)(arg1)->InsertCols(arg2,arg3);
9059 wxPyEndAllowThreads(__tstate);
9060 if (PyErr_Occurred()) SWIG_fail;
9061 }
9062 {
9063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9064 }
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9072 PyObject *resultobj = 0;
9073 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9074 size_t arg2 = (size_t) 1 ;
9075 bool result;
9076 void *argp1 = 0 ;
9077 int res1 = 0 ;
9078 size_t val2 ;
9079 int ecode2 = 0 ;
9080 PyObject * obj0 = 0 ;
9081 PyObject * obj1 = 0 ;
9082 char * kwnames[] = {
9083 (char *) "self",(char *) "numCols", NULL
9084 };
9085
9086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
9087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9088 if (!SWIG_IsOK(res1)) {
9089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9090 }
9091 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9092 if (obj1) {
9093 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9094 if (!SWIG_IsOK(ecode2)) {
9095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
9096 }
9097 arg2 = static_cast< size_t >(val2);
9098 }
9099 {
9100 PyThreadState* __tstate = wxPyBeginAllowThreads();
9101 result = (bool)(arg1)->AppendCols(arg2);
9102 wxPyEndAllowThreads(__tstate);
9103 if (PyErr_Occurred()) SWIG_fail;
9104 }
9105 {
9106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9107 }
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9115 PyObject *resultobj = 0;
9116 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9117 size_t arg2 = (size_t) 0 ;
9118 size_t arg3 = (size_t) 1 ;
9119 bool result;
9120 void *argp1 = 0 ;
9121 int res1 = 0 ;
9122 size_t val2 ;
9123 int ecode2 = 0 ;
9124 size_t val3 ;
9125 int ecode3 = 0 ;
9126 PyObject * obj0 = 0 ;
9127 PyObject * obj1 = 0 ;
9128 PyObject * obj2 = 0 ;
9129 char * kwnames[] = {
9130 (char *) "self",(char *) "pos",(char *) "numCols", NULL
9131 };
9132
9133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9135 if (!SWIG_IsOK(res1)) {
9136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9137 }
9138 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9139 if (obj1) {
9140 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9141 if (!SWIG_IsOK(ecode2)) {
9142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
9143 }
9144 arg2 = static_cast< size_t >(val2);
9145 }
9146 if (obj2) {
9147 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9148 if (!SWIG_IsOK(ecode3)) {
9149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
9150 }
9151 arg3 = static_cast< size_t >(val3);
9152 }
9153 {
9154 PyThreadState* __tstate = wxPyBeginAllowThreads();
9155 result = (bool)(arg1)->DeleteCols(arg2,arg3);
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 {
9160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9161 }
9162 return resultobj;
9163 fail:
9164 return NULL;
9165 }
9166
9167
9168 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9169 PyObject *resultobj = 0;
9170 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9171 int arg2 ;
9172 wxString result;
9173 void *argp1 = 0 ;
9174 int res1 = 0 ;
9175 int val2 ;
9176 int ecode2 = 0 ;
9177 PyObject * obj0 = 0 ;
9178 PyObject * obj1 = 0 ;
9179 char * kwnames[] = {
9180 (char *) "self",(char *) "row", NULL
9181 };
9182
9183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9187 }
9188 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9189 ecode2 = SWIG_AsVal_int(obj1, &val2);
9190 if (!SWIG_IsOK(ecode2)) {
9191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9192 }
9193 arg2 = static_cast< int >(val2);
9194 {
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 result = (arg1)->GetRowLabelValue(arg2);
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 {
9201 #if wxUSE_UNICODE
9202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9203 #else
9204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9205 #endif
9206 }
9207 return resultobj;
9208 fail:
9209 return NULL;
9210 }
9211
9212
9213 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj = 0;
9215 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9216 int arg2 ;
9217 wxString result;
9218 void *argp1 = 0 ;
9219 int res1 = 0 ;
9220 int val2 ;
9221 int ecode2 = 0 ;
9222 PyObject * obj0 = 0 ;
9223 PyObject * obj1 = 0 ;
9224 char * kwnames[] = {
9225 (char *) "self",(char *) "col", NULL
9226 };
9227
9228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
9229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9230 if (!SWIG_IsOK(res1)) {
9231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9232 }
9233 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9234 ecode2 = SWIG_AsVal_int(obj1, &val2);
9235 if (!SWIG_IsOK(ecode2)) {
9236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9237 }
9238 arg2 = static_cast< int >(val2);
9239 {
9240 PyThreadState* __tstate = wxPyBeginAllowThreads();
9241 result = (arg1)->GetColLabelValue(arg2);
9242 wxPyEndAllowThreads(__tstate);
9243 if (PyErr_Occurred()) SWIG_fail;
9244 }
9245 {
9246 #if wxUSE_UNICODE
9247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9248 #else
9249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9250 #endif
9251 }
9252 return resultobj;
9253 fail:
9254 return NULL;
9255 }
9256
9257
9258 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9259 PyObject *resultobj = 0;
9260 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9261 int arg2 ;
9262 wxString *arg3 = 0 ;
9263 void *argp1 = 0 ;
9264 int res1 = 0 ;
9265 int val2 ;
9266 int ecode2 = 0 ;
9267 bool temp3 = false ;
9268 PyObject * obj0 = 0 ;
9269 PyObject * obj1 = 0 ;
9270 PyObject * obj2 = 0 ;
9271 char * kwnames[] = {
9272 (char *) "self",(char *) "row",(char *) "value", NULL
9273 };
9274
9275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9277 if (!SWIG_IsOK(res1)) {
9278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9279 }
9280 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9281 ecode2 = SWIG_AsVal_int(obj1, &val2);
9282 if (!SWIG_IsOK(ecode2)) {
9283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9284 }
9285 arg2 = static_cast< int >(val2);
9286 {
9287 arg3 = wxString_in_helper(obj2);
9288 if (arg3 == NULL) SWIG_fail;
9289 temp3 = true;
9290 }
9291 {
9292 PyThreadState* __tstate = wxPyBeginAllowThreads();
9293 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 resultobj = SWIG_Py_Void();
9298 {
9299 if (temp3)
9300 delete arg3;
9301 }
9302 return resultobj;
9303 fail:
9304 {
9305 if (temp3)
9306 delete arg3;
9307 }
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9313 PyObject *resultobj = 0;
9314 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9315 int arg2 ;
9316 wxString *arg3 = 0 ;
9317 void *argp1 = 0 ;
9318 int res1 = 0 ;
9319 int val2 ;
9320 int ecode2 = 0 ;
9321 bool temp3 = false ;
9322 PyObject * obj0 = 0 ;
9323 PyObject * obj1 = 0 ;
9324 PyObject * obj2 = 0 ;
9325 char * kwnames[] = {
9326 (char *) "self",(char *) "col",(char *) "value", NULL
9327 };
9328
9329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9331 if (!SWIG_IsOK(res1)) {
9332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9333 }
9334 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9335 ecode2 = SWIG_AsVal_int(obj1, &val2);
9336 if (!SWIG_IsOK(ecode2)) {
9337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9338 }
9339 arg2 = static_cast< int >(val2);
9340 {
9341 arg3 = wxString_in_helper(obj2);
9342 if (arg3 == NULL) SWIG_fail;
9343 temp3 = true;
9344 }
9345 {
9346 PyThreadState* __tstate = wxPyBeginAllowThreads();
9347 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9348 wxPyEndAllowThreads(__tstate);
9349 if (PyErr_Occurred()) SWIG_fail;
9350 }
9351 resultobj = SWIG_Py_Void();
9352 {
9353 if (temp3)
9354 delete arg3;
9355 }
9356 return resultobj;
9357 fail:
9358 {
9359 if (temp3)
9360 delete arg3;
9361 }
9362 return NULL;
9363 }
9364
9365
9366 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9367 PyObject *resultobj = 0;
9368 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9369 bool result;
9370 void *argp1 = 0 ;
9371 int res1 = 0 ;
9372 PyObject *swig_obj[1] ;
9373
9374 if (!args) SWIG_fail;
9375 swig_obj[0] = args;
9376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9377 if (!SWIG_IsOK(res1)) {
9378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9379 }
9380 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (bool)(arg1)->CanHaveAttributes();
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9389 }
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj = 0;
9398 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9399 int arg2 ;
9400 int arg3 ;
9401 wxGridCellAttr::wxAttrKind arg4 ;
9402 wxGridCellAttr *result = 0 ;
9403 void *argp1 = 0 ;
9404 int res1 = 0 ;
9405 int val2 ;
9406 int ecode2 = 0 ;
9407 int val3 ;
9408 int ecode3 = 0 ;
9409 int val4 ;
9410 int ecode4 = 0 ;
9411 PyObject * obj0 = 0 ;
9412 PyObject * obj1 = 0 ;
9413 PyObject * obj2 = 0 ;
9414 PyObject * obj3 = 0 ;
9415 char * kwnames[] = {
9416 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9417 };
9418
9419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9421 if (!SWIG_IsOK(res1)) {
9422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9423 }
9424 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9425 ecode2 = SWIG_AsVal_int(obj1, &val2);
9426 if (!SWIG_IsOK(ecode2)) {
9427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9428 }
9429 arg2 = static_cast< int >(val2);
9430 ecode3 = SWIG_AsVal_int(obj2, &val3);
9431 if (!SWIG_IsOK(ecode3)) {
9432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9433 }
9434 arg3 = static_cast< int >(val3);
9435 ecode4 = SWIG_AsVal_int(obj3, &val4);
9436 if (!SWIG_IsOK(ecode4)) {
9437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9438 }
9439 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 {
9447 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9448 }
9449 return resultobj;
9450 fail:
9451 return NULL;
9452 }
9453
9454
9455 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9456 PyObject *resultobj = 0;
9457 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9458 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9459 int arg3 ;
9460 int arg4 ;
9461 void *argp1 = 0 ;
9462 int res1 = 0 ;
9463 void *argp2 = 0 ;
9464 int res2 = 0 ;
9465 int val3 ;
9466 int ecode3 = 0 ;
9467 int val4 ;
9468 int ecode4 = 0 ;
9469 PyObject * obj0 = 0 ;
9470 PyObject * obj1 = 0 ;
9471 PyObject * obj2 = 0 ;
9472 PyObject * obj3 = 0 ;
9473 char * kwnames[] = {
9474 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9475 };
9476
9477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9479 if (!SWIG_IsOK(res1)) {
9480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9481 }
9482 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9484 if (!SWIG_IsOK(res2)) {
9485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9486 }
9487 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9488 ecode3 = SWIG_AsVal_int(obj2, &val3);
9489 if (!SWIG_IsOK(ecode3)) {
9490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9491 }
9492 arg3 = static_cast< int >(val3);
9493 ecode4 = SWIG_AsVal_int(obj3, &val4);
9494 if (!SWIG_IsOK(ecode4)) {
9495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9496 }
9497 arg4 = static_cast< int >(val4);
9498 {
9499 PyThreadState* __tstate = wxPyBeginAllowThreads();
9500 (arg1)->SetAttr(arg2,arg3,arg4);
9501 wxPyEndAllowThreads(__tstate);
9502 if (PyErr_Occurred()) SWIG_fail;
9503 }
9504 resultobj = SWIG_Py_Void();
9505 return resultobj;
9506 fail:
9507 return NULL;
9508 }
9509
9510
9511 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9512 PyObject *resultobj = 0;
9513 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9514 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9515 int arg3 ;
9516 void *argp1 = 0 ;
9517 int res1 = 0 ;
9518 void *argp2 = 0 ;
9519 int res2 = 0 ;
9520 int val3 ;
9521 int ecode3 = 0 ;
9522 PyObject * obj0 = 0 ;
9523 PyObject * obj1 = 0 ;
9524 PyObject * obj2 = 0 ;
9525 char * kwnames[] = {
9526 (char *) "self",(char *) "attr",(char *) "row", NULL
9527 };
9528
9529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9533 }
9534 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9536 if (!SWIG_IsOK(res2)) {
9537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9538 }
9539 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9540 ecode3 = SWIG_AsVal_int(obj2, &val3);
9541 if (!SWIG_IsOK(ecode3)) {
9542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9543 }
9544 arg3 = static_cast< int >(val3);
9545 {
9546 PyThreadState* __tstate = wxPyBeginAllowThreads();
9547 (arg1)->SetRowAttr(arg2,arg3);
9548 wxPyEndAllowThreads(__tstate);
9549 if (PyErr_Occurred()) SWIG_fail;
9550 }
9551 resultobj = SWIG_Py_Void();
9552 return resultobj;
9553 fail:
9554 return NULL;
9555 }
9556
9557
9558 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj = 0;
9560 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9561 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9562 int arg3 ;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 void *argp2 = 0 ;
9566 int res2 = 0 ;
9567 int val3 ;
9568 int ecode3 = 0 ;
9569 PyObject * obj0 = 0 ;
9570 PyObject * obj1 = 0 ;
9571 PyObject * obj2 = 0 ;
9572 char * kwnames[] = {
9573 (char *) "self",(char *) "attr",(char *) "col", NULL
9574 };
9575
9576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9578 if (!SWIG_IsOK(res1)) {
9579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9580 }
9581 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9583 if (!SWIG_IsOK(res2)) {
9584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9585 }
9586 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9587 ecode3 = SWIG_AsVal_int(obj2, &val3);
9588 if (!SWIG_IsOK(ecode3)) {
9589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9590 }
9591 arg3 = static_cast< int >(val3);
9592 {
9593 PyThreadState* __tstate = wxPyBeginAllowThreads();
9594 (arg1)->SetColAttr(arg2,arg3);
9595 wxPyEndAllowThreads(__tstate);
9596 if (PyErr_Occurred()) SWIG_fail;
9597 }
9598 resultobj = SWIG_Py_Void();
9599 return resultobj;
9600 fail:
9601 return NULL;
9602 }
9603
9604
9605 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9606 PyObject *obj;
9607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9608 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9609 return SWIG_Py_Void();
9610 }
9611
9612 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9613 PyObject *resultobj = 0;
9614 wxPyGridTableBase *result = 0 ;
9615
9616 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9617 {
9618 PyThreadState* __tstate = wxPyBeginAllowThreads();
9619 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9620 wxPyEndAllowThreads(__tstate);
9621 if (PyErr_Occurred()) SWIG_fail;
9622 }
9623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9624 return resultobj;
9625 fail:
9626 return NULL;
9627 }
9628
9629
9630 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9631 PyObject *resultobj = 0;
9632 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9633 PyObject *arg2 = (PyObject *) 0 ;
9634 PyObject *arg3 = (PyObject *) 0 ;
9635 void *argp1 = 0 ;
9636 int res1 = 0 ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 PyObject * obj2 = 0 ;
9640 char * kwnames[] = {
9641 (char *) "self",(char *) "self",(char *) "_class", NULL
9642 };
9643
9644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9646 if (!SWIG_IsOK(res1)) {
9647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9648 }
9649 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9650 arg2 = obj1;
9651 arg3 = obj2;
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 (arg1)->_setCallbackInfo(arg2,arg3);
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_Py_Void();
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9666 PyObject *resultobj = 0;
9667 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9668 void *argp1 = 0 ;
9669 int res1 = 0 ;
9670 PyObject *swig_obj[1] ;
9671
9672 if (!args) SWIG_fail;
9673 swig_obj[0] = args;
9674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9675 if (!SWIG_IsOK(res1)) {
9676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9677 }
9678 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9679 {
9680 PyThreadState* __tstate = wxPyBeginAllowThreads();
9681 wxPyGridTableBase_Destroy(arg1);
9682 wxPyEndAllowThreads(__tstate);
9683 if (PyErr_Occurred()) SWIG_fail;
9684 }
9685 resultobj = SWIG_Py_Void();
9686 return resultobj;
9687 fail:
9688 return NULL;
9689 }
9690
9691
9692 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9693 PyObject *obj;
9694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9695 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9696 return SWIG_Py_Void();
9697 }
9698
9699 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9700 return SWIG_Python_InitShadowInstance(args);
9701 }
9702
9703 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj = 0;
9705 int arg1 = (int) 0 ;
9706 int arg2 = (int) 0 ;
9707 wxGridStringTable *result = 0 ;
9708 int val1 ;
9709 int ecode1 = 0 ;
9710 int val2 ;
9711 int ecode2 = 0 ;
9712 PyObject * obj0 = 0 ;
9713 PyObject * obj1 = 0 ;
9714 char * kwnames[] = {
9715 (char *) "numRows",(char *) "numCols", NULL
9716 };
9717
9718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9719 if (obj0) {
9720 ecode1 = SWIG_AsVal_int(obj0, &val1);
9721 if (!SWIG_IsOK(ecode1)) {
9722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9723 }
9724 arg1 = static_cast< int >(val1);
9725 }
9726 if (obj1) {
9727 ecode2 = SWIG_AsVal_int(obj1, &val2);
9728 if (!SWIG_IsOK(ecode2)) {
9729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9730 }
9731 arg2 = static_cast< int >(val2);
9732 }
9733 {
9734 PyThreadState* __tstate = wxPyBeginAllowThreads();
9735 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9736 wxPyEndAllowThreads(__tstate);
9737 if (PyErr_Occurred()) SWIG_fail;
9738 }
9739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9740 return resultobj;
9741 fail:
9742 return NULL;
9743 }
9744
9745
9746 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9747 PyObject *obj;
9748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9749 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9750 return SWIG_Py_Void();
9751 }
9752
9753 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9754 return SWIG_Python_InitShadowInstance(args);
9755 }
9756
9757 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9758 PyObject *resultobj = 0;
9759 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9760 int arg2 ;
9761 int arg3 = (int) -1 ;
9762 int arg4 = (int) -1 ;
9763 wxGridTableMessage *result = 0 ;
9764 void *argp1 = 0 ;
9765 int res1 = 0 ;
9766 int val2 ;
9767 int ecode2 = 0 ;
9768 int val3 ;
9769 int ecode3 = 0 ;
9770 int val4 ;
9771 int ecode4 = 0 ;
9772 PyObject * obj0 = 0 ;
9773 PyObject * obj1 = 0 ;
9774 PyObject * obj2 = 0 ;
9775 PyObject * obj3 = 0 ;
9776 char * kwnames[] = {
9777 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9778 };
9779
9780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9782 if (!SWIG_IsOK(res1)) {
9783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9784 }
9785 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9786 ecode2 = SWIG_AsVal_int(obj1, &val2);
9787 if (!SWIG_IsOK(ecode2)) {
9788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9789 }
9790 arg2 = static_cast< int >(val2);
9791 if (obj2) {
9792 ecode3 = SWIG_AsVal_int(obj2, &val3);
9793 if (!SWIG_IsOK(ecode3)) {
9794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9795 }
9796 arg3 = static_cast< int >(val3);
9797 }
9798 if (obj3) {
9799 ecode4 = SWIG_AsVal_int(obj3, &val4);
9800 if (!SWIG_IsOK(ecode4)) {
9801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9802 }
9803 arg4 = static_cast< int >(val4);
9804 }
9805 {
9806 PyThreadState* __tstate = wxPyBeginAllowThreads();
9807 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9819 PyObject *resultobj = 0;
9820 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9821 void *argp1 = 0 ;
9822 int res1 = 0 ;
9823 PyObject *swig_obj[1] ;
9824
9825 if (!args) SWIG_fail;
9826 swig_obj[0] = args;
9827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9828 if (!SWIG_IsOK(res1)) {
9829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9830 }
9831 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9832 {
9833 PyThreadState* __tstate = wxPyBeginAllowThreads();
9834 delete arg1;
9835
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 resultobj = SWIG_Py_Void();
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9847 PyObject *resultobj = 0;
9848 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9849 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9850 void *argp1 = 0 ;
9851 int res1 = 0 ;
9852 void *argp2 = 0 ;
9853 int res2 = 0 ;
9854 PyObject * obj0 = 0 ;
9855 PyObject * obj1 = 0 ;
9856 char * kwnames[] = {
9857 (char *) "self",(char *) "table", NULL
9858 };
9859
9860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9862 if (!SWIG_IsOK(res1)) {
9863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9864 }
9865 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9866 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9867 if (!SWIG_IsOK(res2)) {
9868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9869 }
9870 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9871 {
9872 PyThreadState* __tstate = wxPyBeginAllowThreads();
9873 (arg1)->SetTableObject(arg2);
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 resultobj = SWIG_Py_Void();
9878 return resultobj;
9879 fail:
9880 return NULL;
9881 }
9882
9883
9884 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9885 PyObject *resultobj = 0;
9886 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9887 wxGridTableBase *result = 0 ;
9888 void *argp1 = 0 ;
9889 int res1 = 0 ;
9890 PyObject *swig_obj[1] ;
9891
9892 if (!args) SWIG_fail;
9893 swig_obj[0] = args;
9894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9895 if (!SWIG_IsOK(res1)) {
9896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9897 }
9898 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9899 {
9900 PyThreadState* __tstate = wxPyBeginAllowThreads();
9901 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9902 wxPyEndAllowThreads(__tstate);
9903 if (PyErr_Occurred()) SWIG_fail;
9904 }
9905 {
9906 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9907 }
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9915 PyObject *resultobj = 0;
9916 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9917 int arg2 ;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 int val2 ;
9921 int ecode2 = 0 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char * kwnames[] = {
9925 (char *) "self",(char *) "id", NULL
9926 };
9927
9928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9930 if (!SWIG_IsOK(res1)) {
9931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9932 }
9933 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9934 ecode2 = SWIG_AsVal_int(obj1, &val2);
9935 if (!SWIG_IsOK(ecode2)) {
9936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9937 }
9938 arg2 = static_cast< int >(val2);
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 (arg1)->SetId(arg2);
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_Py_Void();
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9953 PyObject *resultobj = 0;
9954 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9955 int result;
9956 void *argp1 = 0 ;
9957 int res1 = 0 ;
9958 PyObject *swig_obj[1] ;
9959
9960 if (!args) SWIG_fail;
9961 swig_obj[0] = args;
9962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9963 if (!SWIG_IsOK(res1)) {
9964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9965 }
9966 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9967 {
9968 PyThreadState* __tstate = wxPyBeginAllowThreads();
9969 result = (int)(arg1)->GetId();
9970 wxPyEndAllowThreads(__tstate);
9971 if (PyErr_Occurred()) SWIG_fail;
9972 }
9973 resultobj = SWIG_From_int(static_cast< int >(result));
9974 return resultobj;
9975 fail:
9976 return NULL;
9977 }
9978
9979
9980 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9981 PyObject *resultobj = 0;
9982 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9983 int arg2 ;
9984 void *argp1 = 0 ;
9985 int res1 = 0 ;
9986 int val2 ;
9987 int ecode2 = 0 ;
9988 PyObject * obj0 = 0 ;
9989 PyObject * obj1 = 0 ;
9990 char * kwnames[] = {
9991 (char *) "self",(char *) "comInt1", NULL
9992 };
9993
9994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9996 if (!SWIG_IsOK(res1)) {
9997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9998 }
9999 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10000 ecode2 = SWIG_AsVal_int(obj1, &val2);
10001 if (!SWIG_IsOK(ecode2)) {
10002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
10003 }
10004 arg2 = static_cast< int >(val2);
10005 {
10006 PyThreadState* __tstate = wxPyBeginAllowThreads();
10007 (arg1)->SetCommandInt(arg2);
10008 wxPyEndAllowThreads(__tstate);
10009 if (PyErr_Occurred()) SWIG_fail;
10010 }
10011 resultobj = SWIG_Py_Void();
10012 return resultobj;
10013 fail:
10014 return NULL;
10015 }
10016
10017
10018 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10019 PyObject *resultobj = 0;
10020 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10021 int result;
10022 void *argp1 = 0 ;
10023 int res1 = 0 ;
10024 PyObject *swig_obj[1] ;
10025
10026 if (!args) SWIG_fail;
10027 swig_obj[0] = args;
10028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10029 if (!SWIG_IsOK(res1)) {
10030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10031 }
10032 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10033 {
10034 PyThreadState* __tstate = wxPyBeginAllowThreads();
10035 result = (int)(arg1)->GetCommandInt();
10036 wxPyEndAllowThreads(__tstate);
10037 if (PyErr_Occurred()) SWIG_fail;
10038 }
10039 resultobj = SWIG_From_int(static_cast< int >(result));
10040 return resultobj;
10041 fail:
10042 return NULL;
10043 }
10044
10045
10046 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10047 PyObject *resultobj = 0;
10048 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10049 int arg2 ;
10050 void *argp1 = 0 ;
10051 int res1 = 0 ;
10052 int val2 ;
10053 int ecode2 = 0 ;
10054 PyObject * obj0 = 0 ;
10055 PyObject * obj1 = 0 ;
10056 char * kwnames[] = {
10057 (char *) "self",(char *) "comInt2", NULL
10058 };
10059
10060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
10061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10062 if (!SWIG_IsOK(res1)) {
10063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10064 }
10065 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10066 ecode2 = SWIG_AsVal_int(obj1, &val2);
10067 if (!SWIG_IsOK(ecode2)) {
10068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
10069 }
10070 arg2 = static_cast< int >(val2);
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 (arg1)->SetCommandInt2(arg2);
10074 wxPyEndAllowThreads(__tstate);
10075 if (PyErr_Occurred()) SWIG_fail;
10076 }
10077 resultobj = SWIG_Py_Void();
10078 return resultobj;
10079 fail:
10080 return NULL;
10081 }
10082
10083
10084 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10085 PyObject *resultobj = 0;
10086 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
10087 int result;
10088 void *argp1 = 0 ;
10089 int res1 = 0 ;
10090 PyObject *swig_obj[1] ;
10091
10092 if (!args) SWIG_fail;
10093 swig_obj[0] = args;
10094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
10095 if (!SWIG_IsOK(res1)) {
10096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
10097 }
10098 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
10099 {
10100 PyThreadState* __tstate = wxPyBeginAllowThreads();
10101 result = (int)(arg1)->GetCommandInt2();
10102 wxPyEndAllowThreads(__tstate);
10103 if (PyErr_Occurred()) SWIG_fail;
10104 }
10105 resultobj = SWIG_From_int(static_cast< int >(result));
10106 return resultobj;
10107 fail:
10108 return NULL;
10109 }
10110
10111
10112 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10113 PyObject *obj;
10114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10115 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
10116 return SWIG_Py_Void();
10117 }
10118
10119 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10120 return SWIG_Python_InitShadowInstance(args);
10121 }
10122
10123 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10124 PyObject *resultobj = 0;
10125 int arg1 = (int) -1 ;
10126 int arg2 = (int) -1 ;
10127 wxGridCellCoords *result = 0 ;
10128 int val1 ;
10129 int ecode1 = 0 ;
10130 int val2 ;
10131 int ecode2 = 0 ;
10132 PyObject * obj0 = 0 ;
10133 PyObject * obj1 = 0 ;
10134 char * kwnames[] = {
10135 (char *) "r",(char *) "c", NULL
10136 };
10137
10138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
10139 if (obj0) {
10140 ecode1 = SWIG_AsVal_int(obj0, &val1);
10141 if (!SWIG_IsOK(ecode1)) {
10142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
10143 }
10144 arg1 = static_cast< int >(val1);
10145 }
10146 if (obj1) {
10147 ecode2 = SWIG_AsVal_int(obj1, &val2);
10148 if (!SWIG_IsOK(ecode2)) {
10149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
10150 }
10151 arg2 = static_cast< int >(val2);
10152 }
10153 {
10154 PyThreadState* __tstate = wxPyBeginAllowThreads();
10155 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
10156 wxPyEndAllowThreads(__tstate);
10157 if (PyErr_Occurred()) SWIG_fail;
10158 }
10159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
10160 return resultobj;
10161 fail:
10162 return NULL;
10163 }
10164
10165
10166 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10167 PyObject *resultobj = 0;
10168 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 PyObject *swig_obj[1] ;
10172
10173 if (!args) SWIG_fail;
10174 swig_obj[0] = args;
10175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
10176 if (!SWIG_IsOK(res1)) {
10177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10178 }
10179 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 delete arg1;
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 resultobj = SWIG_Py_Void();
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10195 PyObject *resultobj = 0;
10196 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10197 int result;
10198 void *argp1 = 0 ;
10199 int res1 = 0 ;
10200 PyObject *swig_obj[1] ;
10201
10202 if (!args) SWIG_fail;
10203 swig_obj[0] = args;
10204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10205 if (!SWIG_IsOK(res1)) {
10206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10207 }
10208 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10209 {
10210 PyThreadState* __tstate = wxPyBeginAllowThreads();
10211 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
10212 wxPyEndAllowThreads(__tstate);
10213 if (PyErr_Occurred()) SWIG_fail;
10214 }
10215 resultobj = SWIG_From_int(static_cast< int >(result));
10216 return resultobj;
10217 fail:
10218 return NULL;
10219 }
10220
10221
10222 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj = 0;
10224 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10225 int arg2 ;
10226 void *argp1 = 0 ;
10227 int res1 = 0 ;
10228 int val2 ;
10229 int ecode2 = 0 ;
10230 PyObject * obj0 = 0 ;
10231 PyObject * obj1 = 0 ;
10232 char * kwnames[] = {
10233 (char *) "self",(char *) "n", NULL
10234 };
10235
10236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
10237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10238 if (!SWIG_IsOK(res1)) {
10239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10240 }
10241 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10242 ecode2 = SWIG_AsVal_int(obj1, &val2);
10243 if (!SWIG_IsOK(ecode2)) {
10244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
10245 }
10246 arg2 = static_cast< int >(val2);
10247 {
10248 PyThreadState* __tstate = wxPyBeginAllowThreads();
10249 (arg1)->SetRow(arg2);
10250 wxPyEndAllowThreads(__tstate);
10251 if (PyErr_Occurred()) SWIG_fail;
10252 }
10253 resultobj = SWIG_Py_Void();
10254 return resultobj;
10255 fail:
10256 return NULL;
10257 }
10258
10259
10260 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10261 PyObject *resultobj = 0;
10262 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10263 int result;
10264 void *argp1 = 0 ;
10265 int res1 = 0 ;
10266 PyObject *swig_obj[1] ;
10267
10268 if (!args) SWIG_fail;
10269 swig_obj[0] = args;
10270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10271 if (!SWIG_IsOK(res1)) {
10272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10273 }
10274 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 resultobj = SWIG_From_int(static_cast< int >(result));
10282 return resultobj;
10283 fail:
10284 return NULL;
10285 }
10286
10287
10288 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10289 PyObject *resultobj = 0;
10290 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10291 int arg2 ;
10292 void *argp1 = 0 ;
10293 int res1 = 0 ;
10294 int val2 ;
10295 int ecode2 = 0 ;
10296 PyObject * obj0 = 0 ;
10297 PyObject * obj1 = 0 ;
10298 char * kwnames[] = {
10299 (char *) "self",(char *) "n", NULL
10300 };
10301
10302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10304 if (!SWIG_IsOK(res1)) {
10305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10306 }
10307 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10308 ecode2 = SWIG_AsVal_int(obj1, &val2);
10309 if (!SWIG_IsOK(ecode2)) {
10310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10311 }
10312 arg2 = static_cast< int >(val2);
10313 {
10314 PyThreadState* __tstate = wxPyBeginAllowThreads();
10315 (arg1)->SetCol(arg2);
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 resultobj = SWIG_Py_Void();
10320 return resultobj;
10321 fail:
10322 return NULL;
10323 }
10324
10325
10326 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10327 PyObject *resultobj = 0;
10328 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10329 int arg2 ;
10330 int arg3 ;
10331 void *argp1 = 0 ;
10332 int res1 = 0 ;
10333 int val2 ;
10334 int ecode2 = 0 ;
10335 int val3 ;
10336 int ecode3 = 0 ;
10337 PyObject * obj0 = 0 ;
10338 PyObject * obj1 = 0 ;
10339 PyObject * obj2 = 0 ;
10340 char * kwnames[] = {
10341 (char *) "self",(char *) "row",(char *) "col", NULL
10342 };
10343
10344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10346 if (!SWIG_IsOK(res1)) {
10347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10348 }
10349 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10350 ecode2 = SWIG_AsVal_int(obj1, &val2);
10351 if (!SWIG_IsOK(ecode2)) {
10352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10353 }
10354 arg2 = static_cast< int >(val2);
10355 ecode3 = SWIG_AsVal_int(obj2, &val3);
10356 if (!SWIG_IsOK(ecode3)) {
10357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10358 }
10359 arg3 = static_cast< int >(val3);
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 (arg1)->Set(arg2,arg3);
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 resultobj = SWIG_Py_Void();
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj = 0;
10375 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10376 PyObject *arg2 = (PyObject *) 0 ;
10377 bool result;
10378 void *argp1 = 0 ;
10379 int res1 = 0 ;
10380 PyObject * obj0 = 0 ;
10381 PyObject * obj1 = 0 ;
10382 char * kwnames[] = {
10383 (char *) "self",(char *) "other", NULL
10384 };
10385
10386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10388 if (!SWIG_IsOK(res1)) {
10389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10390 }
10391 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10392 arg2 = obj1;
10393 {
10394 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 {
10398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10399 }
10400 return resultobj;
10401 fail:
10402 return NULL;
10403 }
10404
10405
10406 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10407 PyObject *resultobj = 0;
10408 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10409 PyObject *arg2 = (PyObject *) 0 ;
10410 bool result;
10411 void *argp1 = 0 ;
10412 int res1 = 0 ;
10413 PyObject * obj0 = 0 ;
10414 PyObject * obj1 = 0 ;
10415 char * kwnames[] = {
10416 (char *) "self",(char *) "other", NULL
10417 };
10418
10419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10423 }
10424 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10425 arg2 = obj1;
10426 {
10427 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10428 if (PyErr_Occurred()) SWIG_fail;
10429 }
10430 {
10431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10432 }
10433 return resultobj;
10434 fail:
10435 return NULL;
10436 }
10437
10438
10439 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10440 PyObject *resultobj = 0;
10441 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10442 PyObject *result = 0 ;
10443 void *argp1 = 0 ;
10444 int res1 = 0 ;
10445 PyObject *swig_obj[1] ;
10446
10447 if (!args) SWIG_fail;
10448 swig_obj[0] = args;
10449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10450 if (!SWIG_IsOK(res1)) {
10451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10452 }
10453 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10454 {
10455 PyThreadState* __tstate = wxPyBeginAllowThreads();
10456 result = (PyObject *)wxGridCellCoords_Get(arg1);
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 resultobj = result;
10461 return resultobj;
10462 fail:
10463 return NULL;
10464 }
10465
10466
10467 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10468 PyObject *obj;
10469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10470 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10471 return SWIG_Py_Void();
10472 }
10473
10474 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10475 return SWIG_Python_InitShadowInstance(args);
10476 }
10477
10478 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10479 PyObject *resultobj = 0;
10480 wxWindow *arg1 = (wxWindow *) 0 ;
10481 int arg2 = (int) -1 ;
10482 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10483 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10484 wxSize const &arg4_defvalue = wxDefaultSize ;
10485 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10486 long arg5 = (long) wxWANTS_CHARS ;
10487 wxString const &arg6_defvalue = wxPyGridNameStr ;
10488 wxString *arg6 = (wxString *) &arg6_defvalue ;
10489 wxGrid *result = 0 ;
10490 void *argp1 = 0 ;
10491 int res1 = 0 ;
10492 int val2 ;
10493 int ecode2 = 0 ;
10494 wxPoint temp3 ;
10495 wxSize temp4 ;
10496 long val5 ;
10497 int ecode5 = 0 ;
10498 bool temp6 = false ;
10499 PyObject * obj0 = 0 ;
10500 PyObject * obj1 = 0 ;
10501 PyObject * obj2 = 0 ;
10502 PyObject * obj3 = 0 ;
10503 PyObject * obj4 = 0 ;
10504 PyObject * obj5 = 0 ;
10505 char * kwnames[] = {
10506 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10507 };
10508
10509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10511 if (!SWIG_IsOK(res1)) {
10512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10513 }
10514 arg1 = reinterpret_cast< wxWindow * >(argp1);
10515 if (obj1) {
10516 ecode2 = SWIG_AsVal_int(obj1, &val2);
10517 if (!SWIG_IsOK(ecode2)) {
10518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10519 }
10520 arg2 = static_cast< int >(val2);
10521 }
10522 if (obj2) {
10523 {
10524 arg3 = &temp3;
10525 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10526 }
10527 }
10528 if (obj3) {
10529 {
10530 arg4 = &temp4;
10531 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10532 }
10533 }
10534 if (obj4) {
10535 ecode5 = SWIG_AsVal_long(obj4, &val5);
10536 if (!SWIG_IsOK(ecode5)) {
10537 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10538 }
10539 arg5 = static_cast< long >(val5);
10540 }
10541 if (obj5) {
10542 {
10543 arg6 = wxString_in_helper(obj5);
10544 if (arg6 == NULL) SWIG_fail;
10545 temp6 = true;
10546 }
10547 }
10548 {
10549 if (!wxPyCheckForApp()) SWIG_fail;
10550 PyThreadState* __tstate = wxPyBeginAllowThreads();
10551 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10552 wxPyEndAllowThreads(__tstate);
10553 if (PyErr_Occurred()) SWIG_fail;
10554 }
10555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10556 {
10557 if (temp6)
10558 delete arg6;
10559 }
10560 return resultobj;
10561 fail:
10562 {
10563 if (temp6)
10564 delete arg6;
10565 }
10566 return NULL;
10567 }
10568
10569
10570 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10571 PyObject *resultobj = 0;
10572 wxGrid *result = 0 ;
10573
10574 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10575 {
10576 if (!wxPyCheckForApp()) SWIG_fail;
10577 PyThreadState* __tstate = wxPyBeginAllowThreads();
10578 result = (wxGrid *)new wxGrid();
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10583 return resultobj;
10584 fail:
10585 return NULL;
10586 }
10587
10588
10589 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10590 PyObject *resultobj = 0;
10591 wxGrid *arg1 = (wxGrid *) 0 ;
10592 wxWindow *arg2 = (wxWindow *) 0 ;
10593 int arg3 = (int) -1 ;
10594 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10595 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10596 wxSize const &arg5_defvalue = wxDefaultSize ;
10597 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10598 long arg6 = (long) wxWANTS_CHARS ;
10599 wxString const &arg7_defvalue = wxPyGridNameStr ;
10600 wxString *arg7 = (wxString *) &arg7_defvalue ;
10601 bool result;
10602 void *argp1 = 0 ;
10603 int res1 = 0 ;
10604 void *argp2 = 0 ;
10605 int res2 = 0 ;
10606 int val3 ;
10607 int ecode3 = 0 ;
10608 wxPoint temp4 ;
10609 wxSize temp5 ;
10610 long val6 ;
10611 int ecode6 = 0 ;
10612 bool temp7 = false ;
10613 PyObject * obj0 = 0 ;
10614 PyObject * obj1 = 0 ;
10615 PyObject * obj2 = 0 ;
10616 PyObject * obj3 = 0 ;
10617 PyObject * obj4 = 0 ;
10618 PyObject * obj5 = 0 ;
10619 PyObject * obj6 = 0 ;
10620 char * kwnames[] = {
10621 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10622 };
10623
10624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10626 if (!SWIG_IsOK(res1)) {
10627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10628 }
10629 arg1 = reinterpret_cast< wxGrid * >(argp1);
10630 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10631 if (!SWIG_IsOK(res2)) {
10632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10633 }
10634 arg2 = reinterpret_cast< wxWindow * >(argp2);
10635 if (obj2) {
10636 ecode3 = SWIG_AsVal_int(obj2, &val3);
10637 if (!SWIG_IsOK(ecode3)) {
10638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10639 }
10640 arg3 = static_cast< int >(val3);
10641 }
10642 if (obj3) {
10643 {
10644 arg4 = &temp4;
10645 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10646 }
10647 }
10648 if (obj4) {
10649 {
10650 arg5 = &temp5;
10651 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10652 }
10653 }
10654 if (obj5) {
10655 ecode6 = SWIG_AsVal_long(obj5, &val6);
10656 if (!SWIG_IsOK(ecode6)) {
10657 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10658 }
10659 arg6 = static_cast< long >(val6);
10660 }
10661 if (obj6) {
10662 {
10663 arg7 = wxString_in_helper(obj6);
10664 if (arg7 == NULL) SWIG_fail;
10665 temp7 = true;
10666 }
10667 }
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 {
10675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10676 }
10677 {
10678 if (temp7)
10679 delete arg7;
10680 }
10681 return resultobj;
10682 fail:
10683 {
10684 if (temp7)
10685 delete arg7;
10686 }
10687 return NULL;
10688 }
10689
10690
10691 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj = 0;
10693 wxGrid *arg1 = (wxGrid *) 0 ;
10694 int arg2 ;
10695 int arg3 ;
10696 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10697 bool result;
10698 void *argp1 = 0 ;
10699 int res1 = 0 ;
10700 int val2 ;
10701 int ecode2 = 0 ;
10702 int val3 ;
10703 int ecode3 = 0 ;
10704 int val4 ;
10705 int ecode4 = 0 ;
10706 PyObject * obj0 = 0 ;
10707 PyObject * obj1 = 0 ;
10708 PyObject * obj2 = 0 ;
10709 PyObject * obj3 = 0 ;
10710 char * kwnames[] = {
10711 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10712 };
10713
10714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10716 if (!SWIG_IsOK(res1)) {
10717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10718 }
10719 arg1 = reinterpret_cast< wxGrid * >(argp1);
10720 ecode2 = SWIG_AsVal_int(obj1, &val2);
10721 if (!SWIG_IsOK(ecode2)) {
10722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10723 }
10724 arg2 = static_cast< int >(val2);
10725 ecode3 = SWIG_AsVal_int(obj2, &val3);
10726 if (!SWIG_IsOK(ecode3)) {
10727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10728 }
10729 arg3 = static_cast< int >(val3);
10730 if (obj3) {
10731 ecode4 = SWIG_AsVal_int(obj3, &val4);
10732 if (!SWIG_IsOK(ecode4)) {
10733 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10734 }
10735 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10736 }
10737 {
10738 PyThreadState* __tstate = wxPyBeginAllowThreads();
10739 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10740 wxPyEndAllowThreads(__tstate);
10741 if (PyErr_Occurred()) SWIG_fail;
10742 }
10743 {
10744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10745 }
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj = 0;
10754 wxGrid *arg1 = (wxGrid *) 0 ;
10755 WXGRIDSELECTIONMODES arg2 ;
10756 void *argp1 = 0 ;
10757 int res1 = 0 ;
10758 int val2 ;
10759 int ecode2 = 0 ;
10760 PyObject * obj0 = 0 ;
10761 PyObject * obj1 = 0 ;
10762 char * kwnames[] = {
10763 (char *) "self",(char *) "selmode", NULL
10764 };
10765
10766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10768 if (!SWIG_IsOK(res1)) {
10769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10770 }
10771 arg1 = reinterpret_cast< wxGrid * >(argp1);
10772 ecode2 = SWIG_AsVal_int(obj1, &val2);
10773 if (!SWIG_IsOK(ecode2)) {
10774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10775 }
10776 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 (arg1)->SetSelectionMode(arg2);
10780 wxPyEndAllowThreads(__tstate);
10781 if (PyErr_Occurred()) SWIG_fail;
10782 }
10783 resultobj = SWIG_Py_Void();
10784 return resultobj;
10785 fail:
10786 return NULL;
10787 }
10788
10789
10790 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10791 PyObject *resultobj = 0;
10792 wxGrid *arg1 = (wxGrid *) 0 ;
10793 WXGRIDSELECTIONMODES result;
10794 void *argp1 = 0 ;
10795 int res1 = 0 ;
10796 PyObject *swig_obj[1] ;
10797
10798 if (!args) SWIG_fail;
10799 swig_obj[0] = args;
10800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10801 if (!SWIG_IsOK(res1)) {
10802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10803 }
10804 arg1 = reinterpret_cast< wxGrid * >(argp1);
10805 {
10806 PyThreadState* __tstate = wxPyBeginAllowThreads();
10807 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10808 wxPyEndAllowThreads(__tstate);
10809 if (PyErr_Occurred()) SWIG_fail;
10810 }
10811 resultobj = SWIG_From_int(static_cast< int >(result));
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10819 PyObject *resultobj = 0;
10820 wxGrid *arg1 = (wxGrid *) 0 ;
10821 int result;
10822 void *argp1 = 0 ;
10823 int res1 = 0 ;
10824 PyObject *swig_obj[1] ;
10825
10826 if (!args) SWIG_fail;
10827 swig_obj[0] = args;
10828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10829 if (!SWIG_IsOK(res1)) {
10830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10831 }
10832 arg1 = reinterpret_cast< wxGrid * >(argp1);
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 result = (int)(arg1)->GetNumberRows();
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 resultobj = SWIG_From_int(static_cast< int >(result));
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10847 PyObject *resultobj = 0;
10848 wxGrid *arg1 = (wxGrid *) 0 ;
10849 int result;
10850 void *argp1 = 0 ;
10851 int res1 = 0 ;
10852 PyObject *swig_obj[1] ;
10853
10854 if (!args) SWIG_fail;
10855 swig_obj[0] = args;
10856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10857 if (!SWIG_IsOK(res1)) {
10858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10859 }
10860 arg1 = reinterpret_cast< wxGrid * >(argp1);
10861 {
10862 PyThreadState* __tstate = wxPyBeginAllowThreads();
10863 result = (int)(arg1)->GetNumberCols();
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_From_int(static_cast< int >(result));
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = 0;
10876 wxGrid *arg1 = (wxGrid *) 0 ;
10877 wxGridTableMessage *arg2 = 0 ;
10878 bool result;
10879 void *argp1 = 0 ;
10880 int res1 = 0 ;
10881 void *argp2 = 0 ;
10882 int res2 = 0 ;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 char * kwnames[] = {
10886 (char *) "self",(char *)"arg2", NULL
10887 };
10888
10889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10891 if (!SWIG_IsOK(res1)) {
10892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10893 }
10894 arg1 = reinterpret_cast< wxGrid * >(argp1);
10895 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10896 if (!SWIG_IsOK(res2)) {
10897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10898 }
10899 if (!argp2) {
10900 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10901 }
10902 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10903 {
10904 PyThreadState* __tstate = wxPyBeginAllowThreads();
10905 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 {
10910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10911 }
10912 return resultobj;
10913 fail:
10914 return NULL;
10915 }
10916
10917
10918 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10919 PyObject *resultobj = 0;
10920 wxGrid *arg1 = (wxGrid *) 0 ;
10921 wxGridTableBase *result = 0 ;
10922 void *argp1 = 0 ;
10923 int res1 = 0 ;
10924 PyObject *swig_obj[1] ;
10925
10926 if (!args) SWIG_fail;
10927 swig_obj[0] = args;
10928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10929 if (!SWIG_IsOK(res1)) {
10930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10931 }
10932 arg1 = reinterpret_cast< wxGrid * >(argp1);
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 {
10940 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10941 }
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxGrid *arg1 = (wxGrid *) 0 ;
10951 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10952 bool arg3 = (bool) false ;
10953 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10954 bool result;
10955 void *argp1 = 0 ;
10956 int res1 = 0 ;
10957 int res2 = 0 ;
10958 bool val3 ;
10959 int ecode3 = 0 ;
10960 int val4 ;
10961 int ecode4 = 0 ;
10962 PyObject * obj0 = 0 ;
10963 PyObject * obj1 = 0 ;
10964 PyObject * obj2 = 0 ;
10965 PyObject * obj3 = 0 ;
10966 char * kwnames[] = {
10967 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10968 };
10969
10970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10974 }
10975 arg1 = reinterpret_cast< wxGrid * >(argp1);
10976 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10977 if (!SWIG_IsOK(res2)) {
10978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10979 }
10980 if (obj2) {
10981 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10982 if (!SWIG_IsOK(ecode3)) {
10983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10984 }
10985 arg3 = static_cast< bool >(val3);
10986 }
10987 if (obj3) {
10988 ecode4 = SWIG_AsVal_int(obj3, &val4);
10989 if (!SWIG_IsOK(ecode4)) {
10990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10991 }
10992 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10993 }
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 {
11001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11002 }
11003 return resultobj;
11004 fail:
11005 return NULL;
11006 }
11007
11008
11009 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11010 PyObject *resultobj = 0;
11011 wxGrid *arg1 = (wxGrid *) 0 ;
11012 void *argp1 = 0 ;
11013 int res1 = 0 ;
11014 PyObject *swig_obj[1] ;
11015
11016 if (!args) SWIG_fail;
11017 swig_obj[0] = args;
11018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11019 if (!SWIG_IsOK(res1)) {
11020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
11021 }
11022 arg1 = reinterpret_cast< wxGrid * >(argp1);
11023 {
11024 PyThreadState* __tstate = wxPyBeginAllowThreads();
11025 (arg1)->ClearGrid();
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 resultobj = SWIG_Py_Void();
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj = 0;
11038 wxGrid *arg1 = (wxGrid *) 0 ;
11039 int arg2 = (int) 0 ;
11040 int arg3 = (int) 1 ;
11041 bool arg4 = (bool) true ;
11042 bool result;
11043 void *argp1 = 0 ;
11044 int res1 = 0 ;
11045 int val2 ;
11046 int ecode2 = 0 ;
11047 int val3 ;
11048 int ecode3 = 0 ;
11049 bool val4 ;
11050 int ecode4 = 0 ;
11051 PyObject * obj0 = 0 ;
11052 PyObject * obj1 = 0 ;
11053 PyObject * obj2 = 0 ;
11054 PyObject * obj3 = 0 ;
11055 char * kwnames[] = {
11056 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11057 };
11058
11059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11061 if (!SWIG_IsOK(res1)) {
11062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11063 }
11064 arg1 = reinterpret_cast< wxGrid * >(argp1);
11065 if (obj1) {
11066 ecode2 = SWIG_AsVal_int(obj1, &val2);
11067 if (!SWIG_IsOK(ecode2)) {
11068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
11069 }
11070 arg2 = static_cast< int >(val2);
11071 }
11072 if (obj2) {
11073 ecode3 = SWIG_AsVal_int(obj2, &val3);
11074 if (!SWIG_IsOK(ecode3)) {
11075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
11076 }
11077 arg3 = static_cast< int >(val3);
11078 }
11079 if (obj3) {
11080 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11081 if (!SWIG_IsOK(ecode4)) {
11082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
11083 }
11084 arg4 = static_cast< bool >(val4);
11085 }
11086 {
11087 PyThreadState* __tstate = wxPyBeginAllowThreads();
11088 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
11089 wxPyEndAllowThreads(__tstate);
11090 if (PyErr_Occurred()) SWIG_fail;
11091 }
11092 {
11093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11094 }
11095 return resultobj;
11096 fail:
11097 return NULL;
11098 }
11099
11100
11101 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11102 PyObject *resultobj = 0;
11103 wxGrid *arg1 = (wxGrid *) 0 ;
11104 int arg2 = (int) 1 ;
11105 bool arg3 = (bool) true ;
11106 bool result;
11107 void *argp1 = 0 ;
11108 int res1 = 0 ;
11109 int val2 ;
11110 int ecode2 = 0 ;
11111 bool val3 ;
11112 int ecode3 = 0 ;
11113 PyObject * obj0 = 0 ;
11114 PyObject * obj1 = 0 ;
11115 PyObject * obj2 = 0 ;
11116 char * kwnames[] = {
11117 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
11118 };
11119
11120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11122 if (!SWIG_IsOK(res1)) {
11123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11124 }
11125 arg1 = reinterpret_cast< wxGrid * >(argp1);
11126 if (obj1) {
11127 ecode2 = SWIG_AsVal_int(obj1, &val2);
11128 if (!SWIG_IsOK(ecode2)) {
11129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
11130 }
11131 arg2 = static_cast< int >(val2);
11132 }
11133 if (obj2) {
11134 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11135 if (!SWIG_IsOK(ecode3)) {
11136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
11137 }
11138 arg3 = static_cast< bool >(val3);
11139 }
11140 {
11141 PyThreadState* __tstate = wxPyBeginAllowThreads();
11142 result = (bool)(arg1)->AppendRows(arg2,arg3);
11143 wxPyEndAllowThreads(__tstate);
11144 if (PyErr_Occurred()) SWIG_fail;
11145 }
11146 {
11147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11148 }
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj = 0;
11157 wxGrid *arg1 = (wxGrid *) 0 ;
11158 int arg2 = (int) 0 ;
11159 int arg3 = (int) 1 ;
11160 bool arg4 = (bool) true ;
11161 bool result;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 int val2 ;
11165 int ecode2 = 0 ;
11166 int val3 ;
11167 int ecode3 = 0 ;
11168 bool val4 ;
11169 int ecode4 = 0 ;
11170 PyObject * obj0 = 0 ;
11171 PyObject * obj1 = 0 ;
11172 PyObject * obj2 = 0 ;
11173 PyObject * obj3 = 0 ;
11174 char * kwnames[] = {
11175 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
11176 };
11177
11178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11180 if (!SWIG_IsOK(res1)) {
11181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
11182 }
11183 arg1 = reinterpret_cast< wxGrid * >(argp1);
11184 if (obj1) {
11185 ecode2 = SWIG_AsVal_int(obj1, &val2);
11186 if (!SWIG_IsOK(ecode2)) {
11187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
11188 }
11189 arg2 = static_cast< int >(val2);
11190 }
11191 if (obj2) {
11192 ecode3 = SWIG_AsVal_int(obj2, &val3);
11193 if (!SWIG_IsOK(ecode3)) {
11194 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
11195 }
11196 arg3 = static_cast< int >(val3);
11197 }
11198 if (obj3) {
11199 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11200 if (!SWIG_IsOK(ecode4)) {
11201 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
11202 }
11203 arg4 = static_cast< bool >(val4);
11204 }
11205 {
11206 PyThreadState* __tstate = wxPyBeginAllowThreads();
11207 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
11208 wxPyEndAllowThreads(__tstate);
11209 if (PyErr_Occurred()) SWIG_fail;
11210 }
11211 {
11212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11213 }
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj = 0;
11222 wxGrid *arg1 = (wxGrid *) 0 ;
11223 int arg2 = (int) 0 ;
11224 int arg3 = (int) 1 ;
11225 bool arg4 = (bool) true ;
11226 bool result;
11227 void *argp1 = 0 ;
11228 int res1 = 0 ;
11229 int val2 ;
11230 int ecode2 = 0 ;
11231 int val3 ;
11232 int ecode3 = 0 ;
11233 bool val4 ;
11234 int ecode4 = 0 ;
11235 PyObject * obj0 = 0 ;
11236 PyObject * obj1 = 0 ;
11237 PyObject * obj2 = 0 ;
11238 PyObject * obj3 = 0 ;
11239 char * kwnames[] = {
11240 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11241 };
11242
11243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11245 if (!SWIG_IsOK(res1)) {
11246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11247 }
11248 arg1 = reinterpret_cast< wxGrid * >(argp1);
11249 if (obj1) {
11250 ecode2 = SWIG_AsVal_int(obj1, &val2);
11251 if (!SWIG_IsOK(ecode2)) {
11252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
11253 }
11254 arg2 = static_cast< int >(val2);
11255 }
11256 if (obj2) {
11257 ecode3 = SWIG_AsVal_int(obj2, &val3);
11258 if (!SWIG_IsOK(ecode3)) {
11259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
11260 }
11261 arg3 = static_cast< int >(val3);
11262 }
11263 if (obj3) {
11264 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11265 if (!SWIG_IsOK(ecode4)) {
11266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
11267 }
11268 arg4 = static_cast< bool >(val4);
11269 }
11270 {
11271 PyThreadState* __tstate = wxPyBeginAllowThreads();
11272 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11273 wxPyEndAllowThreads(__tstate);
11274 if (PyErr_Occurred()) SWIG_fail;
11275 }
11276 {
11277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11278 }
11279 return resultobj;
11280 fail:
11281 return NULL;
11282 }
11283
11284
11285 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11286 PyObject *resultobj = 0;
11287 wxGrid *arg1 = (wxGrid *) 0 ;
11288 int arg2 = (int) 1 ;
11289 bool arg3 = (bool) true ;
11290 bool result;
11291 void *argp1 = 0 ;
11292 int res1 = 0 ;
11293 int val2 ;
11294 int ecode2 = 0 ;
11295 bool val3 ;
11296 int ecode3 = 0 ;
11297 PyObject * obj0 = 0 ;
11298 PyObject * obj1 = 0 ;
11299 PyObject * obj2 = 0 ;
11300 char * kwnames[] = {
11301 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11302 };
11303
11304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11306 if (!SWIG_IsOK(res1)) {
11307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11308 }
11309 arg1 = reinterpret_cast< wxGrid * >(argp1);
11310 if (obj1) {
11311 ecode2 = SWIG_AsVal_int(obj1, &val2);
11312 if (!SWIG_IsOK(ecode2)) {
11313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11314 }
11315 arg2 = static_cast< int >(val2);
11316 }
11317 if (obj2) {
11318 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11319 if (!SWIG_IsOK(ecode3)) {
11320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11321 }
11322 arg3 = static_cast< bool >(val3);
11323 }
11324 {
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 result = (bool)(arg1)->AppendCols(arg2,arg3);
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 {
11331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11332 }
11333 return resultobj;
11334 fail:
11335 return NULL;
11336 }
11337
11338
11339 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11340 PyObject *resultobj = 0;
11341 wxGrid *arg1 = (wxGrid *) 0 ;
11342 int arg2 = (int) 0 ;
11343 int arg3 = (int) 1 ;
11344 bool arg4 = (bool) true ;
11345 bool result;
11346 void *argp1 = 0 ;
11347 int res1 = 0 ;
11348 int val2 ;
11349 int ecode2 = 0 ;
11350 int val3 ;
11351 int ecode3 = 0 ;
11352 bool val4 ;
11353 int ecode4 = 0 ;
11354 PyObject * obj0 = 0 ;
11355 PyObject * obj1 = 0 ;
11356 PyObject * obj2 = 0 ;
11357 PyObject * obj3 = 0 ;
11358 char * kwnames[] = {
11359 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11360 };
11361
11362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11364 if (!SWIG_IsOK(res1)) {
11365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11366 }
11367 arg1 = reinterpret_cast< wxGrid * >(argp1);
11368 if (obj1) {
11369 ecode2 = SWIG_AsVal_int(obj1, &val2);
11370 if (!SWIG_IsOK(ecode2)) {
11371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11372 }
11373 arg2 = static_cast< int >(val2);
11374 }
11375 if (obj2) {
11376 ecode3 = SWIG_AsVal_int(obj2, &val3);
11377 if (!SWIG_IsOK(ecode3)) {
11378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11379 }
11380 arg3 = static_cast< int >(val3);
11381 }
11382 if (obj3) {
11383 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11384 if (!SWIG_IsOK(ecode4)) {
11385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11386 }
11387 arg4 = static_cast< bool >(val4);
11388 }
11389 {
11390 PyThreadState* __tstate = wxPyBeginAllowThreads();
11391 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11392 wxPyEndAllowThreads(__tstate);
11393 if (PyErr_Occurred()) SWIG_fail;
11394 }
11395 {
11396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11397 }
11398 return resultobj;
11399 fail:
11400 return NULL;
11401 }
11402
11403
11404 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj = 0;
11406 wxGrid *arg1 = (wxGrid *) 0 ;
11407 wxDC *arg2 = 0 ;
11408 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11409 void *argp1 = 0 ;
11410 int res1 = 0 ;
11411 void *argp2 = 0 ;
11412 int res2 = 0 ;
11413 void *argp3 = 0 ;
11414 int res3 = 0 ;
11415 PyObject * obj0 = 0 ;
11416 PyObject * obj1 = 0 ;
11417 PyObject * obj2 = 0 ;
11418 char * kwnames[] = {
11419 (char *) "self",(char *) "dc",(char *) "attr", NULL
11420 };
11421
11422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11424 if (!SWIG_IsOK(res1)) {
11425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11426 }
11427 arg1 = reinterpret_cast< wxGrid * >(argp1);
11428 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11429 if (!SWIG_IsOK(res2)) {
11430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11431 }
11432 if (!argp2) {
11433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11434 }
11435 arg2 = reinterpret_cast< wxDC * >(argp2);
11436 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11437 if (!SWIG_IsOK(res3)) {
11438 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11439 }
11440 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 resultobj = SWIG_Py_Void();
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11455 PyObject *resultobj = 0;
11456 wxGrid *arg1 = (wxGrid *) 0 ;
11457 wxDC *arg2 = 0 ;
11458 wxString *arg3 = 0 ;
11459 wxRect *arg4 = 0 ;
11460 int arg5 = (int) wxLEFT ;
11461 int arg6 = (int) wxTOP ;
11462 int arg7 = (int) wxHORIZONTAL ;
11463 void *argp1 = 0 ;
11464 int res1 = 0 ;
11465 void *argp2 = 0 ;
11466 int res2 = 0 ;
11467 bool temp3 = false ;
11468 wxRect temp4 ;
11469 int val5 ;
11470 int ecode5 = 0 ;
11471 int val6 ;
11472 int ecode6 = 0 ;
11473 int val7 ;
11474 int ecode7 = 0 ;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 PyObject * obj2 = 0 ;
11478 PyObject * obj3 = 0 ;
11479 PyObject * obj4 = 0 ;
11480 PyObject * obj5 = 0 ;
11481 PyObject * obj6 = 0 ;
11482 char * kwnames[] = {
11483 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11484 };
11485
11486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11488 if (!SWIG_IsOK(res1)) {
11489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11490 }
11491 arg1 = reinterpret_cast< wxGrid * >(argp1);
11492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11493 if (!SWIG_IsOK(res2)) {
11494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11495 }
11496 if (!argp2) {
11497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11498 }
11499 arg2 = reinterpret_cast< wxDC * >(argp2);
11500 {
11501 arg3 = wxString_in_helper(obj2);
11502 if (arg3 == NULL) SWIG_fail;
11503 temp3 = true;
11504 }
11505 {
11506 arg4 = &temp4;
11507 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11508 }
11509 if (obj4) {
11510 ecode5 = SWIG_AsVal_int(obj4, &val5);
11511 if (!SWIG_IsOK(ecode5)) {
11512 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11513 }
11514 arg5 = static_cast< int >(val5);
11515 }
11516 if (obj5) {
11517 ecode6 = SWIG_AsVal_int(obj5, &val6);
11518 if (!SWIG_IsOK(ecode6)) {
11519 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11520 }
11521 arg6 = static_cast< int >(val6);
11522 }
11523 if (obj6) {
11524 ecode7 = SWIG_AsVal_int(obj6, &val7);
11525 if (!SWIG_IsOK(ecode7)) {
11526 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11527 }
11528 arg7 = static_cast< int >(val7);
11529 }
11530 {
11531 PyThreadState* __tstate = wxPyBeginAllowThreads();
11532 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 resultobj = SWIG_Py_Void();
11537 {
11538 if (temp3)
11539 delete arg3;
11540 }
11541 return resultobj;
11542 fail:
11543 {
11544 if (temp3)
11545 delete arg3;
11546 }
11547 return NULL;
11548 }
11549
11550
11551 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11552 PyObject *resultobj = 0;
11553 wxGrid *arg1 = (wxGrid *) 0 ;
11554 wxDC *arg2 = 0 ;
11555 wxArrayString *arg3 = 0 ;
11556 long *arg4 = (long *) 0 ;
11557 long *arg5 = (long *) 0 ;
11558 void *argp1 = 0 ;
11559 int res1 = 0 ;
11560 void *argp2 = 0 ;
11561 int res2 = 0 ;
11562 bool temp3 = false ;
11563 long temp4 ;
11564 int res4 = SWIG_TMPOBJ ;
11565 long temp5 ;
11566 int res5 = SWIG_TMPOBJ ;
11567 PyObject * obj0 = 0 ;
11568 PyObject * obj1 = 0 ;
11569 PyObject * obj2 = 0 ;
11570 char * kwnames[] = {
11571 (char *) "self",(char *) "dc",(char *) "lines", NULL
11572 };
11573
11574 arg4 = &temp4;
11575 arg5 = &temp5;
11576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11578 if (!SWIG_IsOK(res1)) {
11579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11580 }
11581 arg1 = reinterpret_cast< wxGrid * >(argp1);
11582 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11583 if (!SWIG_IsOK(res2)) {
11584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11585 }
11586 if (!argp2) {
11587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11588 }
11589 arg2 = reinterpret_cast< wxDC * >(argp2);
11590 {
11591 if (! PySequence_Check(obj2)) {
11592 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11593 SWIG_fail;
11594 }
11595 arg3 = new wxArrayString;
11596 temp3 = true;
11597 int i, len=PySequence_Length(obj2);
11598 for (i=0; i<len; i++) {
11599 PyObject* item = PySequence_GetItem(obj2, i);
11600 wxString* s = wxString_in_helper(item);
11601 if (PyErr_Occurred()) SWIG_fail;
11602 arg3->Add(*s);
11603 delete s;
11604 Py_DECREF(item);
11605 }
11606 }
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 resultobj = SWIG_Py_Void();
11614 if (SWIG_IsTmpObj(res4)) {
11615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11616 } else {
11617 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11619 }
11620 if (SWIG_IsTmpObj(res5)) {
11621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11622 } else {
11623 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11625 }
11626 {
11627 if (temp3) delete arg3;
11628 }
11629 return resultobj;
11630 fail:
11631 {
11632 if (temp3) delete arg3;
11633 }
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxGrid *arg1 = (wxGrid *) 0 ;
11641 void *argp1 = 0 ;
11642 int res1 = 0 ;
11643 PyObject *swig_obj[1] ;
11644
11645 if (!args) SWIG_fail;
11646 swig_obj[0] = args;
11647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11648 if (!SWIG_IsOK(res1)) {
11649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11650 }
11651 arg1 = reinterpret_cast< wxGrid * >(argp1);
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 (arg1)->BeginBatch();
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 resultobj = SWIG_Py_Void();
11659 return resultobj;
11660 fail:
11661 return NULL;
11662 }
11663
11664
11665 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11666 PyObject *resultobj = 0;
11667 wxGrid *arg1 = (wxGrid *) 0 ;
11668 void *argp1 = 0 ;
11669 int res1 = 0 ;
11670 PyObject *swig_obj[1] ;
11671
11672 if (!args) SWIG_fail;
11673 swig_obj[0] = args;
11674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11675 if (!SWIG_IsOK(res1)) {
11676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11677 }
11678 arg1 = reinterpret_cast< wxGrid * >(argp1);
11679 {
11680 PyThreadState* __tstate = wxPyBeginAllowThreads();
11681 (arg1)->EndBatch();
11682 wxPyEndAllowThreads(__tstate);
11683 if (PyErr_Occurred()) SWIG_fail;
11684 }
11685 resultobj = SWIG_Py_Void();
11686 return resultobj;
11687 fail:
11688 return NULL;
11689 }
11690
11691
11692 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11693 PyObject *resultobj = 0;
11694 wxGrid *arg1 = (wxGrid *) 0 ;
11695 int result;
11696 void *argp1 = 0 ;
11697 int res1 = 0 ;
11698 PyObject *swig_obj[1] ;
11699
11700 if (!args) SWIG_fail;
11701 swig_obj[0] = args;
11702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11703 if (!SWIG_IsOK(res1)) {
11704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11705 }
11706 arg1 = reinterpret_cast< wxGrid * >(argp1);
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (int)(arg1)->GetBatchCount();
11710 wxPyEndAllowThreads(__tstate);
11711 if (PyErr_Occurred()) SWIG_fail;
11712 }
11713 resultobj = SWIG_From_int(static_cast< int >(result));
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11721 PyObject *resultobj = 0;
11722 wxGrid *arg1 = (wxGrid *) 0 ;
11723 void *argp1 = 0 ;
11724 int res1 = 0 ;
11725 PyObject *swig_obj[1] ;
11726
11727 if (!args) SWIG_fail;
11728 swig_obj[0] = args;
11729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11730 if (!SWIG_IsOK(res1)) {
11731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11732 }
11733 arg1 = reinterpret_cast< wxGrid * >(argp1);
11734 {
11735 PyThreadState* __tstate = wxPyBeginAllowThreads();
11736 (arg1)->ForceRefresh();
11737 wxPyEndAllowThreads(__tstate);
11738 if (PyErr_Occurred()) SWIG_fail;
11739 }
11740 resultobj = SWIG_Py_Void();
11741 return resultobj;
11742 fail:
11743 return NULL;
11744 }
11745
11746
11747 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11748 PyObject *resultobj = 0;
11749 wxGrid *arg1 = (wxGrid *) 0 ;
11750 bool result;
11751 void *argp1 = 0 ;
11752 int res1 = 0 ;
11753 PyObject *swig_obj[1] ;
11754
11755 if (!args) SWIG_fail;
11756 swig_obj[0] = args;
11757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11758 if (!SWIG_IsOK(res1)) {
11759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11760 }
11761 arg1 = reinterpret_cast< wxGrid * >(argp1);
11762 {
11763 PyThreadState* __tstate = wxPyBeginAllowThreads();
11764 result = (bool)(arg1)->IsEditable();
11765 wxPyEndAllowThreads(__tstate);
11766 if (PyErr_Occurred()) SWIG_fail;
11767 }
11768 {
11769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11770 }
11771 return resultobj;
11772 fail:
11773 return NULL;
11774 }
11775
11776
11777 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11778 PyObject *resultobj = 0;
11779 wxGrid *arg1 = (wxGrid *) 0 ;
11780 bool arg2 ;
11781 void *argp1 = 0 ;
11782 int res1 = 0 ;
11783 bool val2 ;
11784 int ecode2 = 0 ;
11785 PyObject * obj0 = 0 ;
11786 PyObject * obj1 = 0 ;
11787 char * kwnames[] = {
11788 (char *) "self",(char *) "edit", NULL
11789 };
11790
11791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11793 if (!SWIG_IsOK(res1)) {
11794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11795 }
11796 arg1 = reinterpret_cast< wxGrid * >(argp1);
11797 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11798 if (!SWIG_IsOK(ecode2)) {
11799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11800 }
11801 arg2 = static_cast< bool >(val2);
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 (arg1)->EnableEditing(arg2);
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 resultobj = SWIG_Py_Void();
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj = 0;
11817 wxGrid *arg1 = (wxGrid *) 0 ;
11818 bool arg2 = (bool) true ;
11819 void *argp1 = 0 ;
11820 int res1 = 0 ;
11821 bool val2 ;
11822 int ecode2 = 0 ;
11823 PyObject * obj0 = 0 ;
11824 PyObject * obj1 = 0 ;
11825 char * kwnames[] = {
11826 (char *) "self",(char *) "enable", NULL
11827 };
11828
11829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11831 if (!SWIG_IsOK(res1)) {
11832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11833 }
11834 arg1 = reinterpret_cast< wxGrid * >(argp1);
11835 if (obj1) {
11836 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11837 if (!SWIG_IsOK(ecode2)) {
11838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11839 }
11840 arg2 = static_cast< bool >(val2);
11841 }
11842 {
11843 PyThreadState* __tstate = wxPyBeginAllowThreads();
11844 (arg1)->EnableCellEditControl(arg2);
11845 wxPyEndAllowThreads(__tstate);
11846 if (PyErr_Occurred()) SWIG_fail;
11847 }
11848 resultobj = SWIG_Py_Void();
11849 return resultobj;
11850 fail:
11851 return NULL;
11852 }
11853
11854
11855 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11856 PyObject *resultobj = 0;
11857 wxGrid *arg1 = (wxGrid *) 0 ;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 PyObject *swig_obj[1] ;
11861
11862 if (!args) SWIG_fail;
11863 swig_obj[0] = args;
11864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11865 if (!SWIG_IsOK(res1)) {
11866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11867 }
11868 arg1 = reinterpret_cast< wxGrid * >(argp1);
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 (arg1)->DisableCellEditControl();
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 resultobj = SWIG_Py_Void();
11876 return resultobj;
11877 fail:
11878 return NULL;
11879 }
11880
11881
11882 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11883 PyObject *resultobj = 0;
11884 wxGrid *arg1 = (wxGrid *) 0 ;
11885 bool result;
11886 void *argp1 = 0 ;
11887 int res1 = 0 ;
11888 PyObject *swig_obj[1] ;
11889
11890 if (!args) SWIG_fail;
11891 swig_obj[0] = args;
11892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11893 if (!SWIG_IsOK(res1)) {
11894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11895 }
11896 arg1 = reinterpret_cast< wxGrid * >(argp1);
11897 {
11898 PyThreadState* __tstate = wxPyBeginAllowThreads();
11899 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11900 wxPyEndAllowThreads(__tstate);
11901 if (PyErr_Occurred()) SWIG_fail;
11902 }
11903 {
11904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11905 }
11906 return resultobj;
11907 fail:
11908 return NULL;
11909 }
11910
11911
11912 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11913 PyObject *resultobj = 0;
11914 wxGrid *arg1 = (wxGrid *) 0 ;
11915 bool result;
11916 void *argp1 = 0 ;
11917 int res1 = 0 ;
11918 PyObject *swig_obj[1] ;
11919
11920 if (!args) SWIG_fail;
11921 swig_obj[0] = args;
11922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11923 if (!SWIG_IsOK(res1)) {
11924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11925 }
11926 arg1 = reinterpret_cast< wxGrid * >(argp1);
11927 {
11928 PyThreadState* __tstate = wxPyBeginAllowThreads();
11929 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11930 wxPyEndAllowThreads(__tstate);
11931 if (PyErr_Occurred()) SWIG_fail;
11932 }
11933 {
11934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11935 }
11936 return resultobj;
11937 fail:
11938 return NULL;
11939 }
11940
11941
11942 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11943 PyObject *resultobj = 0;
11944 wxGrid *arg1 = (wxGrid *) 0 ;
11945 bool result;
11946 void *argp1 = 0 ;
11947 int res1 = 0 ;
11948 PyObject *swig_obj[1] ;
11949
11950 if (!args) SWIG_fail;
11951 swig_obj[0] = args;
11952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11953 if (!SWIG_IsOK(res1)) {
11954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11955 }
11956 arg1 = reinterpret_cast< wxGrid * >(argp1);
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11960 wxPyEndAllowThreads(__tstate);
11961 if (PyErr_Occurred()) SWIG_fail;
11962 }
11963 {
11964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11965 }
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11973 PyObject *resultobj = 0;
11974 wxGrid *arg1 = (wxGrid *) 0 ;
11975 bool result;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978 PyObject *swig_obj[1] ;
11979
11980 if (!args) SWIG_fail;
11981 swig_obj[0] = args;
11982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11983 if (!SWIG_IsOK(res1)) {
11984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11985 }
11986 arg1 = reinterpret_cast< wxGrid * >(argp1);
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 {
11994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11995 }
11996 return resultobj;
11997 fail:
11998 return NULL;
11999 }
12000
12001
12002 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12003 PyObject *resultobj = 0;
12004 wxGrid *arg1 = (wxGrid *) 0 ;
12005 void *argp1 = 0 ;
12006 int res1 = 0 ;
12007 PyObject *swig_obj[1] ;
12008
12009 if (!args) SWIG_fail;
12010 swig_obj[0] = args;
12011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12012 if (!SWIG_IsOK(res1)) {
12013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12014 }
12015 arg1 = reinterpret_cast< wxGrid * >(argp1);
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 (arg1)->ShowCellEditControl();
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 resultobj = SWIG_Py_Void();
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12030 PyObject *resultobj = 0;
12031 wxGrid *arg1 = (wxGrid *) 0 ;
12032 void *argp1 = 0 ;
12033 int res1 = 0 ;
12034 PyObject *swig_obj[1] ;
12035
12036 if (!args) SWIG_fail;
12037 swig_obj[0] = args;
12038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12039 if (!SWIG_IsOK(res1)) {
12040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
12041 }
12042 arg1 = reinterpret_cast< wxGrid * >(argp1);
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 (arg1)->HideCellEditControl();
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 resultobj = SWIG_Py_Void();
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12057 PyObject *resultobj = 0;
12058 wxGrid *arg1 = (wxGrid *) 0 ;
12059 void *argp1 = 0 ;
12060 int res1 = 0 ;
12061 PyObject *swig_obj[1] ;
12062
12063 if (!args) SWIG_fail;
12064 swig_obj[0] = args;
12065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12066 if (!SWIG_IsOK(res1)) {
12067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12068 }
12069 arg1 = reinterpret_cast< wxGrid * >(argp1);
12070 {
12071 PyThreadState* __tstate = wxPyBeginAllowThreads();
12072 (arg1)->SaveEditControlValue();
12073 wxPyEndAllowThreads(__tstate);
12074 if (PyErr_Occurred()) SWIG_fail;
12075 }
12076 resultobj = SWIG_Py_Void();
12077 return resultobj;
12078 fail:
12079 return NULL;
12080 }
12081
12082
12083 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12084 PyObject *resultobj = 0;
12085 wxGrid *arg1 = (wxGrid *) 0 ;
12086 int arg2 ;
12087 int arg3 ;
12088 wxGridCellCoords result;
12089 void *argp1 = 0 ;
12090 int res1 = 0 ;
12091 int val2 ;
12092 int ecode2 = 0 ;
12093 int val3 ;
12094 int ecode3 = 0 ;
12095 PyObject * obj0 = 0 ;
12096 PyObject * obj1 = 0 ;
12097 PyObject * obj2 = 0 ;
12098 char * kwnames[] = {
12099 (char *) "self",(char *) "x",(char *) "y", NULL
12100 };
12101
12102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12104 if (!SWIG_IsOK(res1)) {
12105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
12106 }
12107 arg1 = reinterpret_cast< wxGrid * >(argp1);
12108 ecode2 = SWIG_AsVal_int(obj1, &val2);
12109 if (!SWIG_IsOK(ecode2)) {
12110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
12111 }
12112 arg2 = static_cast< int >(val2);
12113 ecode3 = SWIG_AsVal_int(obj2, &val3);
12114 if (!SWIG_IsOK(ecode3)) {
12115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
12116 }
12117 arg3 = static_cast< int >(val3);
12118 {
12119 PyThreadState* __tstate = wxPyBeginAllowThreads();
12120 result = wxGrid_XYToCell(arg1,arg2,arg3);
12121 wxPyEndAllowThreads(__tstate);
12122 if (PyErr_Occurred()) SWIG_fail;
12123 }
12124 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
12125 return resultobj;
12126 fail:
12127 return NULL;
12128 }
12129
12130
12131 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12132 PyObject *resultobj = 0;
12133 wxGrid *arg1 = (wxGrid *) 0 ;
12134 int arg2 ;
12135 int result;
12136 void *argp1 = 0 ;
12137 int res1 = 0 ;
12138 int val2 ;
12139 int ecode2 = 0 ;
12140 PyObject * obj0 = 0 ;
12141 PyObject * obj1 = 0 ;
12142 char * kwnames[] = {
12143 (char *) "self",(char *) "y", NULL
12144 };
12145
12146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
12147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12148 if (!SWIG_IsOK(res1)) {
12149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12150 }
12151 arg1 = reinterpret_cast< wxGrid * >(argp1);
12152 ecode2 = SWIG_AsVal_int(obj1, &val2);
12153 if (!SWIG_IsOK(ecode2)) {
12154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
12155 }
12156 arg2 = static_cast< int >(val2);
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 result = (int)(arg1)->YToRow(arg2);
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_From_int(static_cast< int >(result));
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj = 0;
12172 wxGrid *arg1 = (wxGrid *) 0 ;
12173 int arg2 ;
12174 bool arg3 = (bool) false ;
12175 int result;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 int val2 ;
12179 int ecode2 = 0 ;
12180 bool val3 ;
12181 int ecode3 = 0 ;
12182 PyObject * obj0 = 0 ;
12183 PyObject * obj1 = 0 ;
12184 PyObject * obj2 = 0 ;
12185 char * kwnames[] = {
12186 (char *) "self",(char *) "x",(char *) "clipToMinMax", NULL
12187 };
12188
12189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_XToCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12191 if (!SWIG_IsOK(res1)) {
12192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12193 }
12194 arg1 = reinterpret_cast< wxGrid * >(argp1);
12195 ecode2 = SWIG_AsVal_int(obj1, &val2);
12196 if (!SWIG_IsOK(ecode2)) {
12197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
12198 }
12199 arg2 = static_cast< int >(val2);
12200 if (obj2) {
12201 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12202 if (!SWIG_IsOK(ecode3)) {
12203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XToCol" "', expected argument " "3"" of type '" "bool""'");
12204 }
12205 arg3 = static_cast< bool >(val3);
12206 }
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 result = (int)(arg1)->XToCol(arg2,arg3);
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 resultobj = SWIG_From_int(static_cast< int >(result));
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12221 PyObject *resultobj = 0;
12222 wxGrid *arg1 = (wxGrid *) 0 ;
12223 int arg2 ;
12224 int result;
12225 void *argp1 = 0 ;
12226 int res1 = 0 ;
12227 int val2 ;
12228 int ecode2 = 0 ;
12229 PyObject * obj0 = 0 ;
12230 PyObject * obj1 = 0 ;
12231 char * kwnames[] = {
12232 (char *) "self",(char *) "y", NULL
12233 };
12234
12235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
12236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12237 if (!SWIG_IsOK(res1)) {
12238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12239 }
12240 arg1 = reinterpret_cast< wxGrid * >(argp1);
12241 ecode2 = SWIG_AsVal_int(obj1, &val2);
12242 if (!SWIG_IsOK(ecode2)) {
12243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
12244 }
12245 arg2 = static_cast< int >(val2);
12246 {
12247 PyThreadState* __tstate = wxPyBeginAllowThreads();
12248 result = (int)(arg1)->YToEdgeOfRow(arg2);
12249 wxPyEndAllowThreads(__tstate);
12250 if (PyErr_Occurred()) SWIG_fail;
12251 }
12252 resultobj = SWIG_From_int(static_cast< int >(result));
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj = 0;
12261 wxGrid *arg1 = (wxGrid *) 0 ;
12262 int arg2 ;
12263 int result;
12264 void *argp1 = 0 ;
12265 int res1 = 0 ;
12266 int val2 ;
12267 int ecode2 = 0 ;
12268 PyObject * obj0 = 0 ;
12269 PyObject * obj1 = 0 ;
12270 char * kwnames[] = {
12271 (char *) "self",(char *) "x", NULL
12272 };
12273
12274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
12275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12276 if (!SWIG_IsOK(res1)) {
12277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12278 }
12279 arg1 = reinterpret_cast< wxGrid * >(argp1);
12280 ecode2 = SWIG_AsVal_int(obj1, &val2);
12281 if (!SWIG_IsOK(ecode2)) {
12282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
12283 }
12284 arg2 = static_cast< int >(val2);
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (int)(arg1)->XToEdgeOfCol(arg2);
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 resultobj = SWIG_From_int(static_cast< int >(result));
12292 return resultobj;
12293 fail:
12294 return NULL;
12295 }
12296
12297
12298 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12299 PyObject *resultobj = 0;
12300 wxGrid *arg1 = (wxGrid *) 0 ;
12301 int arg2 ;
12302 int arg3 ;
12303 wxRect result;
12304 void *argp1 = 0 ;
12305 int res1 = 0 ;
12306 int val2 ;
12307 int ecode2 = 0 ;
12308 int val3 ;
12309 int ecode3 = 0 ;
12310 PyObject * obj0 = 0 ;
12311 PyObject * obj1 = 0 ;
12312 PyObject * obj2 = 0 ;
12313 char * kwnames[] = {
12314 (char *) "self",(char *) "row",(char *) "col", NULL
12315 };
12316
12317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12319 if (!SWIG_IsOK(res1)) {
12320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12321 }
12322 arg1 = reinterpret_cast< wxGrid * >(argp1);
12323 ecode2 = SWIG_AsVal_int(obj1, &val2);
12324 if (!SWIG_IsOK(ecode2)) {
12325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12326 }
12327 arg2 = static_cast< int >(val2);
12328 ecode3 = SWIG_AsVal_int(obj2, &val3);
12329 if (!SWIG_IsOK(ecode3)) {
12330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12331 }
12332 arg3 = static_cast< int >(val3);
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 result = (arg1)->CellToRect(arg2,arg3);
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12347 PyObject *resultobj = 0;
12348 wxGrid *arg1 = (wxGrid *) 0 ;
12349 int result;
12350 void *argp1 = 0 ;
12351 int res1 = 0 ;
12352 PyObject *swig_obj[1] ;
12353
12354 if (!args) SWIG_fail;
12355 swig_obj[0] = args;
12356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12357 if (!SWIG_IsOK(res1)) {
12358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12359 }
12360 arg1 = reinterpret_cast< wxGrid * >(argp1);
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 result = (int)(arg1)->GetGridCursorRow();
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 resultobj = SWIG_From_int(static_cast< int >(result));
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12375 PyObject *resultobj = 0;
12376 wxGrid *arg1 = (wxGrid *) 0 ;
12377 int result;
12378 void *argp1 = 0 ;
12379 int res1 = 0 ;
12380 PyObject *swig_obj[1] ;
12381
12382 if (!args) SWIG_fail;
12383 swig_obj[0] = args;
12384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12385 if (!SWIG_IsOK(res1)) {
12386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12387 }
12388 arg1 = reinterpret_cast< wxGrid * >(argp1);
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (int)(arg1)->GetGridCursorCol();
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 resultobj = SWIG_From_int(static_cast< int >(result));
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj = 0;
12404 wxGrid *arg1 = (wxGrid *) 0 ;
12405 int arg2 ;
12406 int arg3 ;
12407 bool arg4 = (bool) true ;
12408 bool result;
12409 void *argp1 = 0 ;
12410 int res1 = 0 ;
12411 int val2 ;
12412 int ecode2 = 0 ;
12413 int val3 ;
12414 int ecode3 = 0 ;
12415 bool val4 ;
12416 int ecode4 = 0 ;
12417 PyObject * obj0 = 0 ;
12418 PyObject * obj1 = 0 ;
12419 PyObject * obj2 = 0 ;
12420 PyObject * obj3 = 0 ;
12421 char * kwnames[] = {
12422 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12423 };
12424
12425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12427 if (!SWIG_IsOK(res1)) {
12428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12429 }
12430 arg1 = reinterpret_cast< wxGrid * >(argp1);
12431 ecode2 = SWIG_AsVal_int(obj1, &val2);
12432 if (!SWIG_IsOK(ecode2)) {
12433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12434 }
12435 arg2 = static_cast< int >(val2);
12436 ecode3 = SWIG_AsVal_int(obj2, &val3);
12437 if (!SWIG_IsOK(ecode3)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12439 }
12440 arg3 = static_cast< int >(val3);
12441 if (obj3) {
12442 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12443 if (!SWIG_IsOK(ecode4)) {
12444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12445 }
12446 arg4 = static_cast< bool >(val4);
12447 }
12448 {
12449 PyThreadState* __tstate = wxPyBeginAllowThreads();
12450 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12451 wxPyEndAllowThreads(__tstate);
12452 if (PyErr_Occurred()) SWIG_fail;
12453 }
12454 {
12455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12456 }
12457 return resultobj;
12458 fail:
12459 return NULL;
12460 }
12461
12462
12463 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12464 PyObject *resultobj = 0;
12465 wxGrid *arg1 = (wxGrid *) 0 ;
12466 int arg2 ;
12467 int arg3 ;
12468 void *argp1 = 0 ;
12469 int res1 = 0 ;
12470 int val2 ;
12471 int ecode2 = 0 ;
12472 int val3 ;
12473 int ecode3 = 0 ;
12474 PyObject * obj0 = 0 ;
12475 PyObject * obj1 = 0 ;
12476 PyObject * obj2 = 0 ;
12477 char * kwnames[] = {
12478 (char *) "self",(char *) "row",(char *) "col", NULL
12479 };
12480
12481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12485 }
12486 arg1 = reinterpret_cast< wxGrid * >(argp1);
12487 ecode2 = SWIG_AsVal_int(obj1, &val2);
12488 if (!SWIG_IsOK(ecode2)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12490 }
12491 arg2 = static_cast< int >(val2);
12492 ecode3 = SWIG_AsVal_int(obj2, &val3);
12493 if (!SWIG_IsOK(ecode3)) {
12494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12495 }
12496 arg3 = static_cast< int >(val3);
12497 {
12498 PyThreadState* __tstate = wxPyBeginAllowThreads();
12499 (arg1)->MakeCellVisible(arg2,arg3);
12500 wxPyEndAllowThreads(__tstate);
12501 if (PyErr_Occurred()) SWIG_fail;
12502 }
12503 resultobj = SWIG_Py_Void();
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12511 PyObject *resultobj = 0;
12512 wxGrid *arg1 = (wxGrid *) 0 ;
12513 int arg2 ;
12514 int arg3 ;
12515 void *argp1 = 0 ;
12516 int res1 = 0 ;
12517 int val2 ;
12518 int ecode2 = 0 ;
12519 int val3 ;
12520 int ecode3 = 0 ;
12521 PyObject * obj0 = 0 ;
12522 PyObject * obj1 = 0 ;
12523 PyObject * obj2 = 0 ;
12524 char * kwnames[] = {
12525 (char *) "self",(char *) "row",(char *) "col", NULL
12526 };
12527
12528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12530 if (!SWIG_IsOK(res1)) {
12531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12532 }
12533 arg1 = reinterpret_cast< wxGrid * >(argp1);
12534 ecode2 = SWIG_AsVal_int(obj1, &val2);
12535 if (!SWIG_IsOK(ecode2)) {
12536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12537 }
12538 arg2 = static_cast< int >(val2);
12539 ecode3 = SWIG_AsVal_int(obj2, &val3);
12540 if (!SWIG_IsOK(ecode3)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12542 }
12543 arg3 = static_cast< int >(val3);
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 (arg1)->SetGridCursor(arg2,arg3);
12547 wxPyEndAllowThreads(__tstate);
12548 if (PyErr_Occurred()) SWIG_fail;
12549 }
12550 resultobj = SWIG_Py_Void();
12551 return resultobj;
12552 fail:
12553 return NULL;
12554 }
12555
12556
12557 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12558 PyObject *resultobj = 0;
12559 wxGrid *arg1 = (wxGrid *) 0 ;
12560 bool arg2 ;
12561 bool result;
12562 void *argp1 = 0 ;
12563 int res1 = 0 ;
12564 bool val2 ;
12565 int ecode2 = 0 ;
12566 PyObject * obj0 = 0 ;
12567 PyObject * obj1 = 0 ;
12568 char * kwnames[] = {
12569 (char *) "self",(char *) "expandSelection", NULL
12570 };
12571
12572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12574 if (!SWIG_IsOK(res1)) {
12575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12576 }
12577 arg1 = reinterpret_cast< wxGrid * >(argp1);
12578 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12579 if (!SWIG_IsOK(ecode2)) {
12580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12581 }
12582 arg2 = static_cast< bool >(val2);
12583 {
12584 PyThreadState* __tstate = wxPyBeginAllowThreads();
12585 result = (bool)(arg1)->MoveCursorUp(arg2);
12586 wxPyEndAllowThreads(__tstate);
12587 if (PyErr_Occurred()) SWIG_fail;
12588 }
12589 {
12590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12591 }
12592 return resultobj;
12593 fail:
12594 return NULL;
12595 }
12596
12597
12598 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12599 PyObject *resultobj = 0;
12600 wxGrid *arg1 = (wxGrid *) 0 ;
12601 bool arg2 ;
12602 bool result;
12603 void *argp1 = 0 ;
12604 int res1 = 0 ;
12605 bool val2 ;
12606 int ecode2 = 0 ;
12607 PyObject * obj0 = 0 ;
12608 PyObject * obj1 = 0 ;
12609 char * kwnames[] = {
12610 (char *) "self",(char *) "expandSelection", NULL
12611 };
12612
12613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12615 if (!SWIG_IsOK(res1)) {
12616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12617 }
12618 arg1 = reinterpret_cast< wxGrid * >(argp1);
12619 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12620 if (!SWIG_IsOK(ecode2)) {
12621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12622 }
12623 arg2 = static_cast< bool >(val2);
12624 {
12625 PyThreadState* __tstate = wxPyBeginAllowThreads();
12626 result = (bool)(arg1)->MoveCursorDown(arg2);
12627 wxPyEndAllowThreads(__tstate);
12628 if (PyErr_Occurred()) SWIG_fail;
12629 }
12630 {
12631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12632 }
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj = 0;
12641 wxGrid *arg1 = (wxGrid *) 0 ;
12642 bool arg2 ;
12643 bool result;
12644 void *argp1 = 0 ;
12645 int res1 = 0 ;
12646 bool val2 ;
12647 int ecode2 = 0 ;
12648 PyObject * obj0 = 0 ;
12649 PyObject * obj1 = 0 ;
12650 char * kwnames[] = {
12651 (char *) "self",(char *) "expandSelection", NULL
12652 };
12653
12654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12656 if (!SWIG_IsOK(res1)) {
12657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12658 }
12659 arg1 = reinterpret_cast< wxGrid * >(argp1);
12660 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12661 if (!SWIG_IsOK(ecode2)) {
12662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12663 }
12664 arg2 = static_cast< bool >(val2);
12665 {
12666 PyThreadState* __tstate = wxPyBeginAllowThreads();
12667 result = (bool)(arg1)->MoveCursorLeft(arg2);
12668 wxPyEndAllowThreads(__tstate);
12669 if (PyErr_Occurred()) SWIG_fail;
12670 }
12671 {
12672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12673 }
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12681 PyObject *resultobj = 0;
12682 wxGrid *arg1 = (wxGrid *) 0 ;
12683 bool arg2 ;
12684 bool result;
12685 void *argp1 = 0 ;
12686 int res1 = 0 ;
12687 bool val2 ;
12688 int ecode2 = 0 ;
12689 PyObject * obj0 = 0 ;
12690 PyObject * obj1 = 0 ;
12691 char * kwnames[] = {
12692 (char *) "self",(char *) "expandSelection", NULL
12693 };
12694
12695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12697 if (!SWIG_IsOK(res1)) {
12698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12699 }
12700 arg1 = reinterpret_cast< wxGrid * >(argp1);
12701 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12702 if (!SWIG_IsOK(ecode2)) {
12703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12704 }
12705 arg2 = static_cast< bool >(val2);
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 result = (bool)(arg1)->MoveCursorRight(arg2);
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 {
12713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12714 }
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12722 PyObject *resultobj = 0;
12723 wxGrid *arg1 = (wxGrid *) 0 ;
12724 bool result;
12725 void *argp1 = 0 ;
12726 int res1 = 0 ;
12727 PyObject *swig_obj[1] ;
12728
12729 if (!args) SWIG_fail;
12730 swig_obj[0] = args;
12731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12732 if (!SWIG_IsOK(res1)) {
12733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12734 }
12735 arg1 = reinterpret_cast< wxGrid * >(argp1);
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (bool)(arg1)->MovePageDown();
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 {
12743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12744 }
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 wxGrid *arg1 = (wxGrid *) 0 ;
12754 bool result;
12755 void *argp1 = 0 ;
12756 int res1 = 0 ;
12757 PyObject *swig_obj[1] ;
12758
12759 if (!args) SWIG_fail;
12760 swig_obj[0] = args;
12761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12762 if (!SWIG_IsOK(res1)) {
12763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12764 }
12765 arg1 = reinterpret_cast< wxGrid * >(argp1);
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 result = (bool)(arg1)->MovePageUp();
12769 wxPyEndAllowThreads(__tstate);
12770 if (PyErr_Occurred()) SWIG_fail;
12771 }
12772 {
12773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12774 }
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj = 0;
12783 wxGrid *arg1 = (wxGrid *) 0 ;
12784 bool arg2 ;
12785 bool result;
12786 void *argp1 = 0 ;
12787 int res1 = 0 ;
12788 bool val2 ;
12789 int ecode2 = 0 ;
12790 PyObject * obj0 = 0 ;
12791 PyObject * obj1 = 0 ;
12792 char * kwnames[] = {
12793 (char *) "self",(char *) "expandSelection", NULL
12794 };
12795
12796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12798 if (!SWIG_IsOK(res1)) {
12799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12800 }
12801 arg1 = reinterpret_cast< wxGrid * >(argp1);
12802 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12803 if (!SWIG_IsOK(ecode2)) {
12804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12805 }
12806 arg2 = static_cast< bool >(val2);
12807 {
12808 PyThreadState* __tstate = wxPyBeginAllowThreads();
12809 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12810 wxPyEndAllowThreads(__tstate);
12811 if (PyErr_Occurred()) SWIG_fail;
12812 }
12813 {
12814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12815 }
12816 return resultobj;
12817 fail:
12818 return NULL;
12819 }
12820
12821
12822 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12823 PyObject *resultobj = 0;
12824 wxGrid *arg1 = (wxGrid *) 0 ;
12825 bool arg2 ;
12826 bool result;
12827 void *argp1 = 0 ;
12828 int res1 = 0 ;
12829 bool val2 ;
12830 int ecode2 = 0 ;
12831 PyObject * obj0 = 0 ;
12832 PyObject * obj1 = 0 ;
12833 char * kwnames[] = {
12834 (char *) "self",(char *) "expandSelection", NULL
12835 };
12836
12837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12839 if (!SWIG_IsOK(res1)) {
12840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12841 }
12842 arg1 = reinterpret_cast< wxGrid * >(argp1);
12843 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12844 if (!SWIG_IsOK(ecode2)) {
12845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12846 }
12847 arg2 = static_cast< bool >(val2);
12848 {
12849 PyThreadState* __tstate = wxPyBeginAllowThreads();
12850 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12851 wxPyEndAllowThreads(__tstate);
12852 if (PyErr_Occurred()) SWIG_fail;
12853 }
12854 {
12855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12856 }
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12864 PyObject *resultobj = 0;
12865 wxGrid *arg1 = (wxGrid *) 0 ;
12866 bool arg2 ;
12867 bool result;
12868 void *argp1 = 0 ;
12869 int res1 = 0 ;
12870 bool val2 ;
12871 int ecode2 = 0 ;
12872 PyObject * obj0 = 0 ;
12873 PyObject * obj1 = 0 ;
12874 char * kwnames[] = {
12875 (char *) "self",(char *) "expandSelection", NULL
12876 };
12877
12878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12880 if (!SWIG_IsOK(res1)) {
12881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12882 }
12883 arg1 = reinterpret_cast< wxGrid * >(argp1);
12884 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12885 if (!SWIG_IsOK(ecode2)) {
12886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12887 }
12888 arg2 = static_cast< bool >(val2);
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 {
12896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12897 }
12898 return resultobj;
12899 fail:
12900 return NULL;
12901 }
12902
12903
12904 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12905 PyObject *resultobj = 0;
12906 wxGrid *arg1 = (wxGrid *) 0 ;
12907 bool arg2 ;
12908 bool result;
12909 void *argp1 = 0 ;
12910 int res1 = 0 ;
12911 bool val2 ;
12912 int ecode2 = 0 ;
12913 PyObject * obj0 = 0 ;
12914 PyObject * obj1 = 0 ;
12915 char * kwnames[] = {
12916 (char *) "self",(char *) "expandSelection", NULL
12917 };
12918
12919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12921 if (!SWIG_IsOK(res1)) {
12922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12923 }
12924 arg1 = reinterpret_cast< wxGrid * >(argp1);
12925 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12926 if (!SWIG_IsOK(ecode2)) {
12927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12928 }
12929 arg2 = static_cast< bool >(val2);
12930 {
12931 PyThreadState* __tstate = wxPyBeginAllowThreads();
12932 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 {
12937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12938 }
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12946 PyObject *resultobj = 0;
12947 wxGrid *arg1 = (wxGrid *) 0 ;
12948 int result;
12949 void *argp1 = 0 ;
12950 int res1 = 0 ;
12951 PyObject *swig_obj[1] ;
12952
12953 if (!args) SWIG_fail;
12954 swig_obj[0] = args;
12955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12956 if (!SWIG_IsOK(res1)) {
12957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12958 }
12959 arg1 = reinterpret_cast< wxGrid * >(argp1);
12960 {
12961 PyThreadState* __tstate = wxPyBeginAllowThreads();
12962 result = (int)(arg1)->GetDefaultRowLabelSize();
12963 wxPyEndAllowThreads(__tstate);
12964 if (PyErr_Occurred()) SWIG_fail;
12965 }
12966 resultobj = SWIG_From_int(static_cast< int >(result));
12967 return resultobj;
12968 fail:
12969 return NULL;
12970 }
12971
12972
12973 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12974 PyObject *resultobj = 0;
12975 wxGrid *arg1 = (wxGrid *) 0 ;
12976 int result;
12977 void *argp1 = 0 ;
12978 int res1 = 0 ;
12979 PyObject *swig_obj[1] ;
12980
12981 if (!args) SWIG_fail;
12982 swig_obj[0] = args;
12983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12984 if (!SWIG_IsOK(res1)) {
12985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12986 }
12987 arg1 = reinterpret_cast< wxGrid * >(argp1);
12988 {
12989 PyThreadState* __tstate = wxPyBeginAllowThreads();
12990 result = (int)(arg1)->GetRowLabelSize();
12991 wxPyEndAllowThreads(__tstate);
12992 if (PyErr_Occurred()) SWIG_fail;
12993 }
12994 resultobj = SWIG_From_int(static_cast< int >(result));
12995 return resultobj;
12996 fail:
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13002 PyObject *resultobj = 0;
13003 wxGrid *arg1 = (wxGrid *) 0 ;
13004 int result;
13005 void *argp1 = 0 ;
13006 int res1 = 0 ;
13007 PyObject *swig_obj[1] ;
13008
13009 if (!args) SWIG_fail;
13010 swig_obj[0] = args;
13011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13012 if (!SWIG_IsOK(res1)) {
13013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13014 }
13015 arg1 = reinterpret_cast< wxGrid * >(argp1);
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (int)(arg1)->GetDefaultColLabelSize();
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 resultobj = SWIG_From_int(static_cast< int >(result));
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13030 PyObject *resultobj = 0;
13031 wxGrid *arg1 = (wxGrid *) 0 ;
13032 int result;
13033 void *argp1 = 0 ;
13034 int res1 = 0 ;
13035 PyObject *swig_obj[1] ;
13036
13037 if (!args) SWIG_fail;
13038 swig_obj[0] = args;
13039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13040 if (!SWIG_IsOK(res1)) {
13041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13042 }
13043 arg1 = reinterpret_cast< wxGrid * >(argp1);
13044 {
13045 PyThreadState* __tstate = wxPyBeginAllowThreads();
13046 result = (int)(arg1)->GetColLabelSize();
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 resultobj = SWIG_From_int(static_cast< int >(result));
13051 return resultobj;
13052 fail:
13053 return NULL;
13054 }
13055
13056
13057 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13058 PyObject *resultobj = 0;
13059 wxGrid *arg1 = (wxGrid *) 0 ;
13060 wxColour result;
13061 void *argp1 = 0 ;
13062 int res1 = 0 ;
13063 PyObject *swig_obj[1] ;
13064
13065 if (!args) SWIG_fail;
13066 swig_obj[0] = args;
13067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13068 if (!SWIG_IsOK(res1)) {
13069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13070 }
13071 arg1 = reinterpret_cast< wxGrid * >(argp1);
13072 {
13073 PyThreadState* __tstate = wxPyBeginAllowThreads();
13074 result = (arg1)->GetLabelBackgroundColour();
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13086 PyObject *resultobj = 0;
13087 wxGrid *arg1 = (wxGrid *) 0 ;
13088 wxColour result;
13089 void *argp1 = 0 ;
13090 int res1 = 0 ;
13091 PyObject *swig_obj[1] ;
13092
13093 if (!args) SWIG_fail;
13094 swig_obj[0] = args;
13095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13096 if (!SWIG_IsOK(res1)) {
13097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13098 }
13099 arg1 = reinterpret_cast< wxGrid * >(argp1);
13100 {
13101 PyThreadState* __tstate = wxPyBeginAllowThreads();
13102 result = (arg1)->GetLabelTextColour();
13103 wxPyEndAllowThreads(__tstate);
13104 if (PyErr_Occurred()) SWIG_fail;
13105 }
13106 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13107 return resultobj;
13108 fail:
13109 return NULL;
13110 }
13111
13112
13113 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114 PyObject *resultobj = 0;
13115 wxGrid *arg1 = (wxGrid *) 0 ;
13116 wxFont result;
13117 void *argp1 = 0 ;
13118 int res1 = 0 ;
13119 PyObject *swig_obj[1] ;
13120
13121 if (!args) SWIG_fail;
13122 swig_obj[0] = args;
13123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13124 if (!SWIG_IsOK(res1)) {
13125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13126 }
13127 arg1 = reinterpret_cast< wxGrid * >(argp1);
13128 {
13129 PyThreadState* __tstate = wxPyBeginAllowThreads();
13130 result = (arg1)->GetLabelFont();
13131 wxPyEndAllowThreads(__tstate);
13132 if (PyErr_Occurred()) SWIG_fail;
13133 }
13134 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
13135 return resultobj;
13136 fail:
13137 return NULL;
13138 }
13139
13140
13141 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13142 PyObject *resultobj = 0;
13143 wxGrid *arg1 = (wxGrid *) 0 ;
13144 int *arg2 = (int *) 0 ;
13145 int *arg3 = (int *) 0 ;
13146 void *argp1 = 0 ;
13147 int res1 = 0 ;
13148 int temp2 ;
13149 int res2 = SWIG_TMPOBJ ;
13150 int temp3 ;
13151 int res3 = SWIG_TMPOBJ ;
13152 PyObject *swig_obj[1] ;
13153
13154 arg2 = &temp2;
13155 arg3 = &temp3;
13156 if (!args) SWIG_fail;
13157 swig_obj[0] = args;
13158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13159 if (!SWIG_IsOK(res1)) {
13160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13161 }
13162 arg1 = reinterpret_cast< wxGrid * >(argp1);
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 (arg1)->GetRowLabelAlignment(arg2,arg3);
13166 wxPyEndAllowThreads(__tstate);
13167 if (PyErr_Occurred()) SWIG_fail;
13168 }
13169 resultobj = SWIG_Py_Void();
13170 if (SWIG_IsTmpObj(res2)) {
13171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13172 } else {
13173 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13175 }
13176 if (SWIG_IsTmpObj(res3)) {
13177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13178 } else {
13179 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13181 }
13182 return resultobj;
13183 fail:
13184 return NULL;
13185 }
13186
13187
13188 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13189 PyObject *resultobj = 0;
13190 wxGrid *arg1 = (wxGrid *) 0 ;
13191 int *arg2 = (int *) 0 ;
13192 int *arg3 = (int *) 0 ;
13193 void *argp1 = 0 ;
13194 int res1 = 0 ;
13195 int temp2 ;
13196 int res2 = SWIG_TMPOBJ ;
13197 int temp3 ;
13198 int res3 = SWIG_TMPOBJ ;
13199 PyObject *swig_obj[1] ;
13200
13201 arg2 = &temp2;
13202 arg3 = &temp3;
13203 if (!args) SWIG_fail;
13204 swig_obj[0] = args;
13205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13206 if (!SWIG_IsOK(res1)) {
13207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13208 }
13209 arg1 = reinterpret_cast< wxGrid * >(argp1);
13210 {
13211 PyThreadState* __tstate = wxPyBeginAllowThreads();
13212 (arg1)->GetColLabelAlignment(arg2,arg3);
13213 wxPyEndAllowThreads(__tstate);
13214 if (PyErr_Occurred()) SWIG_fail;
13215 }
13216 resultobj = SWIG_Py_Void();
13217 if (SWIG_IsTmpObj(res2)) {
13218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13219 } else {
13220 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13222 }
13223 if (SWIG_IsTmpObj(res3)) {
13224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
13225 } else {
13226 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13228 }
13229 return resultobj;
13230 fail:
13231 return NULL;
13232 }
13233
13234
13235 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13236 PyObject *resultobj = 0;
13237 wxGrid *arg1 = (wxGrid *) 0 ;
13238 int result;
13239 void *argp1 = 0 ;
13240 int res1 = 0 ;
13241 PyObject *swig_obj[1] ;
13242
13243 if (!args) SWIG_fail;
13244 swig_obj[0] = args;
13245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13246 if (!SWIG_IsOK(res1)) {
13247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13248 }
13249 arg1 = reinterpret_cast< wxGrid * >(argp1);
13250 {
13251 PyThreadState* __tstate = wxPyBeginAllowThreads();
13252 result = (int)(arg1)->GetColLabelTextOrientation();
13253 wxPyEndAllowThreads(__tstate);
13254 if (PyErr_Occurred()) SWIG_fail;
13255 }
13256 resultobj = SWIG_From_int(static_cast< int >(result));
13257 return resultobj;
13258 fail:
13259 return NULL;
13260 }
13261
13262
13263 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13264 PyObject *resultobj = 0;
13265 wxGrid *arg1 = (wxGrid *) 0 ;
13266 int arg2 ;
13267 wxString result;
13268 void *argp1 = 0 ;
13269 int res1 = 0 ;
13270 int val2 ;
13271 int ecode2 = 0 ;
13272 PyObject * obj0 = 0 ;
13273 PyObject * obj1 = 0 ;
13274 char * kwnames[] = {
13275 (char *) "self",(char *) "row", NULL
13276 };
13277
13278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13280 if (!SWIG_IsOK(res1)) {
13281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13282 }
13283 arg1 = reinterpret_cast< wxGrid * >(argp1);
13284 ecode2 = SWIG_AsVal_int(obj1, &val2);
13285 if (!SWIG_IsOK(ecode2)) {
13286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13287 }
13288 arg2 = static_cast< int >(val2);
13289 {
13290 PyThreadState* __tstate = wxPyBeginAllowThreads();
13291 result = (arg1)->GetRowLabelValue(arg2);
13292 wxPyEndAllowThreads(__tstate);
13293 if (PyErr_Occurred()) SWIG_fail;
13294 }
13295 {
13296 #if wxUSE_UNICODE
13297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13298 #else
13299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13300 #endif
13301 }
13302 return resultobj;
13303 fail:
13304 return NULL;
13305 }
13306
13307
13308 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13309 PyObject *resultobj = 0;
13310 wxGrid *arg1 = (wxGrid *) 0 ;
13311 int arg2 ;
13312 wxString result;
13313 void *argp1 = 0 ;
13314 int res1 = 0 ;
13315 int val2 ;
13316 int ecode2 = 0 ;
13317 PyObject * obj0 = 0 ;
13318 PyObject * obj1 = 0 ;
13319 char * kwnames[] = {
13320 (char *) "self",(char *) "col", NULL
13321 };
13322
13323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13325 if (!SWIG_IsOK(res1)) {
13326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13327 }
13328 arg1 = reinterpret_cast< wxGrid * >(argp1);
13329 ecode2 = SWIG_AsVal_int(obj1, &val2);
13330 if (!SWIG_IsOK(ecode2)) {
13331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13332 }
13333 arg2 = static_cast< int >(val2);
13334 {
13335 PyThreadState* __tstate = wxPyBeginAllowThreads();
13336 result = (arg1)->GetColLabelValue(arg2);
13337 wxPyEndAllowThreads(__tstate);
13338 if (PyErr_Occurred()) SWIG_fail;
13339 }
13340 {
13341 #if wxUSE_UNICODE
13342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13343 #else
13344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13345 #endif
13346 }
13347 return resultobj;
13348 fail:
13349 return NULL;
13350 }
13351
13352
13353 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13354 PyObject *resultobj = 0;
13355 wxGrid *arg1 = (wxGrid *) 0 ;
13356 wxColour result;
13357 void *argp1 = 0 ;
13358 int res1 = 0 ;
13359 PyObject *swig_obj[1] ;
13360
13361 if (!args) SWIG_fail;
13362 swig_obj[0] = args;
13363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13364 if (!SWIG_IsOK(res1)) {
13365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13366 }
13367 arg1 = reinterpret_cast< wxGrid * >(argp1);
13368 {
13369 PyThreadState* __tstate = wxPyBeginAllowThreads();
13370 result = (arg1)->GetGridLineColour();
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 SWIGINTERN PyObject *_wrap_Grid_GetDefaultGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13382 PyObject *resultobj = 0;
13383 wxGrid *arg1 = (wxGrid *) 0 ;
13384 wxPen result;
13385 void *argp1 = 0 ;
13386 int res1 = 0 ;
13387 PyObject *swig_obj[1] ;
13388
13389 if (!args) SWIG_fail;
13390 swig_obj[0] = args;
13391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13392 if (!SWIG_IsOK(res1)) {
13393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13394 }
13395 arg1 = reinterpret_cast< wxGrid * >(argp1);
13396 {
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 result = (arg1)->GetDefaultGridLinePen();
13399 wxPyEndAllowThreads(__tstate);
13400 if (PyErr_Occurred()) SWIG_fail;
13401 }
13402 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 SWIGINTERN PyObject *_wrap_Grid_GetRowGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13410 PyObject *resultobj = 0;
13411 wxGrid *arg1 = (wxGrid *) 0 ;
13412 int arg2 ;
13413 wxPen result;
13414 void *argp1 = 0 ;
13415 int res1 = 0 ;
13416 int val2 ;
13417 int ecode2 = 0 ;
13418 PyObject * obj0 = 0 ;
13419 PyObject * obj1 = 0 ;
13420 char * kwnames[] = {
13421 (char *) "self",(char *) "row", NULL
13422 };
13423
13424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13426 if (!SWIG_IsOK(res1)) {
13427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13428 }
13429 arg1 = reinterpret_cast< wxGrid * >(argp1);
13430 ecode2 = SWIG_AsVal_int(obj1, &val2);
13431 if (!SWIG_IsOK(ecode2)) {
13432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowGridLinePen" "', expected argument " "2"" of type '" "int""'");
13433 }
13434 arg2 = static_cast< int >(val2);
13435 {
13436 PyThreadState* __tstate = wxPyBeginAllowThreads();
13437 result = (arg1)->GetRowGridLinePen(arg2);
13438 wxPyEndAllowThreads(__tstate);
13439 if (PyErr_Occurred()) SWIG_fail;
13440 }
13441 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13442 return resultobj;
13443 fail:
13444 return NULL;
13445 }
13446
13447
13448 SWIGINTERN PyObject *_wrap_Grid_GetColGridLinePen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13449 PyObject *resultobj = 0;
13450 wxGrid *arg1 = (wxGrid *) 0 ;
13451 int arg2 ;
13452 wxPen result;
13453 void *argp1 = 0 ;
13454 int res1 = 0 ;
13455 int val2 ;
13456 int ecode2 = 0 ;
13457 PyObject * obj0 = 0 ;
13458 PyObject * obj1 = 0 ;
13459 char * kwnames[] = {
13460 (char *) "self",(char *) "col", NULL
13461 };
13462
13463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColGridLinePen",kwnames,&obj0,&obj1)) SWIG_fail;
13464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13465 if (!SWIG_IsOK(res1)) {
13466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColGridLinePen" "', expected argument " "1"" of type '" "wxGrid *""'");
13467 }
13468 arg1 = reinterpret_cast< wxGrid * >(argp1);
13469 ecode2 = SWIG_AsVal_int(obj1, &val2);
13470 if (!SWIG_IsOK(ecode2)) {
13471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColGridLinePen" "', expected argument " "2"" of type '" "int""'");
13472 }
13473 arg2 = static_cast< int >(val2);
13474 {
13475 PyThreadState* __tstate = wxPyBeginAllowThreads();
13476 result = (arg1)->GetColGridLinePen(arg2);
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 resultobj = SWIG_NewPointerObj((new wxPen(static_cast< const wxPen& >(result))), SWIGTYPE_p_wxPen, SWIG_POINTER_OWN | 0 );
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13488 PyObject *resultobj = 0;
13489 wxGrid *arg1 = (wxGrid *) 0 ;
13490 wxColour result;
13491 void *argp1 = 0 ;
13492 int res1 = 0 ;
13493 PyObject *swig_obj[1] ;
13494
13495 if (!args) SWIG_fail;
13496 swig_obj[0] = args;
13497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13500 }
13501 arg1 = reinterpret_cast< wxGrid * >(argp1);
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 result = (arg1)->GetCellHighlightColour();
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13509 return resultobj;
13510 fail:
13511 return NULL;
13512 }
13513
13514
13515 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13516 PyObject *resultobj = 0;
13517 wxGrid *arg1 = (wxGrid *) 0 ;
13518 int result;
13519 void *argp1 = 0 ;
13520 int res1 = 0 ;
13521 PyObject *swig_obj[1] ;
13522
13523 if (!args) SWIG_fail;
13524 swig_obj[0] = args;
13525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13526 if (!SWIG_IsOK(res1)) {
13527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13528 }
13529 arg1 = reinterpret_cast< wxGrid * >(argp1);
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (int)(arg1)->GetCellHighlightPenWidth();
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 resultobj = SWIG_From_int(static_cast< int >(result));
13537 return resultobj;
13538 fail:
13539 return NULL;
13540 }
13541
13542
13543 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13544 PyObject *resultobj = 0;
13545 wxGrid *arg1 = (wxGrid *) 0 ;
13546 int result;
13547 void *argp1 = 0 ;
13548 int res1 = 0 ;
13549 PyObject *swig_obj[1] ;
13550
13551 if (!args) SWIG_fail;
13552 swig_obj[0] = args;
13553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13554 if (!SWIG_IsOK(res1)) {
13555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13556 }
13557 arg1 = reinterpret_cast< wxGrid * >(argp1);
13558 {
13559 PyThreadState* __tstate = wxPyBeginAllowThreads();
13560 result = (int)(arg1)->GetCellHighlightROPenWidth();
13561 wxPyEndAllowThreads(__tstate);
13562 if (PyErr_Occurred()) SWIG_fail;
13563 }
13564 resultobj = SWIG_From_int(static_cast< int >(result));
13565 return resultobj;
13566 fail:
13567 return NULL;
13568 }
13569
13570
13571 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj = 0;
13573 wxGrid *arg1 = (wxGrid *) 0 ;
13574 int arg2 ;
13575 void *argp1 = 0 ;
13576 int res1 = 0 ;
13577 int val2 ;
13578 int ecode2 = 0 ;
13579 PyObject * obj0 = 0 ;
13580 PyObject * obj1 = 0 ;
13581 char * kwnames[] = {
13582 (char *) "self",(char *) "width", NULL
13583 };
13584
13585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13587 if (!SWIG_IsOK(res1)) {
13588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13589 }
13590 arg1 = reinterpret_cast< wxGrid * >(argp1);
13591 ecode2 = SWIG_AsVal_int(obj1, &val2);
13592 if (!SWIG_IsOK(ecode2)) {
13593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13594 }
13595 arg2 = static_cast< int >(val2);
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 (arg1)->SetRowLabelSize(arg2);
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 resultobj = SWIG_Py_Void();
13603 return resultobj;
13604 fail:
13605 return NULL;
13606 }
13607
13608
13609 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13610 PyObject *resultobj = 0;
13611 wxGrid *arg1 = (wxGrid *) 0 ;
13612 int arg2 ;
13613 void *argp1 = 0 ;
13614 int res1 = 0 ;
13615 int val2 ;
13616 int ecode2 = 0 ;
13617 PyObject * obj0 = 0 ;
13618 PyObject * obj1 = 0 ;
13619 char * kwnames[] = {
13620 (char *) "self",(char *) "height", NULL
13621 };
13622
13623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13625 if (!SWIG_IsOK(res1)) {
13626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13627 }
13628 arg1 = reinterpret_cast< wxGrid * >(argp1);
13629 ecode2 = SWIG_AsVal_int(obj1, &val2);
13630 if (!SWIG_IsOK(ecode2)) {
13631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13632 }
13633 arg2 = static_cast< int >(val2);
13634 {
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 (arg1)->SetColLabelSize(arg2);
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 resultobj = SWIG_Py_Void();
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj = 0;
13649 wxGrid *arg1 = (wxGrid *) 0 ;
13650 wxColour *arg2 = 0 ;
13651 void *argp1 = 0 ;
13652 int res1 = 0 ;
13653 wxColour temp2 ;
13654 PyObject * obj0 = 0 ;
13655 PyObject * obj1 = 0 ;
13656 char * kwnames[] = {
13657 (char *) "self",(char *)"arg2", NULL
13658 };
13659
13660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13662 if (!SWIG_IsOK(res1)) {
13663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13664 }
13665 arg1 = reinterpret_cast< wxGrid * >(argp1);
13666 {
13667 arg2 = &temp2;
13668 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13669 }
13670 {
13671 PyThreadState* __tstate = wxPyBeginAllowThreads();
13672 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13673 wxPyEndAllowThreads(__tstate);
13674 if (PyErr_Occurred()) SWIG_fail;
13675 }
13676 resultobj = SWIG_Py_Void();
13677 return resultobj;
13678 fail:
13679 return NULL;
13680 }
13681
13682
13683 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13684 PyObject *resultobj = 0;
13685 wxGrid *arg1 = (wxGrid *) 0 ;
13686 wxColour *arg2 = 0 ;
13687 void *argp1 = 0 ;
13688 int res1 = 0 ;
13689 wxColour temp2 ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 char * kwnames[] = {
13693 (char *) "self",(char *)"arg2", NULL
13694 };
13695
13696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13698 if (!SWIG_IsOK(res1)) {
13699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13700 }
13701 arg1 = reinterpret_cast< wxGrid * >(argp1);
13702 {
13703 arg2 = &temp2;
13704 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13705 }
13706 {
13707 PyThreadState* __tstate = wxPyBeginAllowThreads();
13708 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13709 wxPyEndAllowThreads(__tstate);
13710 if (PyErr_Occurred()) SWIG_fail;
13711 }
13712 resultobj = SWIG_Py_Void();
13713 return resultobj;
13714 fail:
13715 return NULL;
13716 }
13717
13718
13719 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13720 PyObject *resultobj = 0;
13721 wxGrid *arg1 = (wxGrid *) 0 ;
13722 wxFont *arg2 = 0 ;
13723 void *argp1 = 0 ;
13724 int res1 = 0 ;
13725 void *argp2 = 0 ;
13726 int res2 = 0 ;
13727 PyObject * obj0 = 0 ;
13728 PyObject * obj1 = 0 ;
13729 char * kwnames[] = {
13730 (char *) "self",(char *)"arg2", NULL
13731 };
13732
13733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13735 if (!SWIG_IsOK(res1)) {
13736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13737 }
13738 arg1 = reinterpret_cast< wxGrid * >(argp1);
13739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13740 if (!SWIG_IsOK(res2)) {
13741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13742 }
13743 if (!argp2) {
13744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13745 }
13746 arg2 = reinterpret_cast< wxFont * >(argp2);
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 (arg1)->SetLabelFont((wxFont const &)*arg2);
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 resultobj = SWIG_Py_Void();
13754 return resultobj;
13755 fail:
13756 return NULL;
13757 }
13758
13759
13760 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13761 PyObject *resultobj = 0;
13762 wxGrid *arg1 = (wxGrid *) 0 ;
13763 int arg2 ;
13764 int arg3 ;
13765 void *argp1 = 0 ;
13766 int res1 = 0 ;
13767 int val2 ;
13768 int ecode2 = 0 ;
13769 int val3 ;
13770 int ecode3 = 0 ;
13771 PyObject * obj0 = 0 ;
13772 PyObject * obj1 = 0 ;
13773 PyObject * obj2 = 0 ;
13774 char * kwnames[] = {
13775 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13776 };
13777
13778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13780 if (!SWIG_IsOK(res1)) {
13781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13782 }
13783 arg1 = reinterpret_cast< wxGrid * >(argp1);
13784 ecode2 = SWIG_AsVal_int(obj1, &val2);
13785 if (!SWIG_IsOK(ecode2)) {
13786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13787 }
13788 arg2 = static_cast< int >(val2);
13789 ecode3 = SWIG_AsVal_int(obj2, &val3);
13790 if (!SWIG_IsOK(ecode3)) {
13791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13792 }
13793 arg3 = static_cast< int >(val3);
13794 {
13795 PyThreadState* __tstate = wxPyBeginAllowThreads();
13796 (arg1)->SetRowLabelAlignment(arg2,arg3);
13797 wxPyEndAllowThreads(__tstate);
13798 if (PyErr_Occurred()) SWIG_fail;
13799 }
13800 resultobj = SWIG_Py_Void();
13801 return resultobj;
13802 fail:
13803 return NULL;
13804 }
13805
13806
13807 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13808 PyObject *resultobj = 0;
13809 wxGrid *arg1 = (wxGrid *) 0 ;
13810 int arg2 ;
13811 int arg3 ;
13812 void *argp1 = 0 ;
13813 int res1 = 0 ;
13814 int val2 ;
13815 int ecode2 = 0 ;
13816 int val3 ;
13817 int ecode3 = 0 ;
13818 PyObject * obj0 = 0 ;
13819 PyObject * obj1 = 0 ;
13820 PyObject * obj2 = 0 ;
13821 char * kwnames[] = {
13822 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13823 };
13824
13825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13827 if (!SWIG_IsOK(res1)) {
13828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13829 }
13830 arg1 = reinterpret_cast< wxGrid * >(argp1);
13831 ecode2 = SWIG_AsVal_int(obj1, &val2);
13832 if (!SWIG_IsOK(ecode2)) {
13833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13834 }
13835 arg2 = static_cast< int >(val2);
13836 ecode3 = SWIG_AsVal_int(obj2, &val3);
13837 if (!SWIG_IsOK(ecode3)) {
13838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13839 }
13840 arg3 = static_cast< int >(val3);
13841 {
13842 PyThreadState* __tstate = wxPyBeginAllowThreads();
13843 (arg1)->SetColLabelAlignment(arg2,arg3);
13844 wxPyEndAllowThreads(__tstate);
13845 if (PyErr_Occurred()) SWIG_fail;
13846 }
13847 resultobj = SWIG_Py_Void();
13848 return resultobj;
13849 fail:
13850 return NULL;
13851 }
13852
13853
13854 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13855 PyObject *resultobj = 0;
13856 wxGrid *arg1 = (wxGrid *) 0 ;
13857 int arg2 ;
13858 void *argp1 = 0 ;
13859 int res1 = 0 ;
13860 int val2 ;
13861 int ecode2 = 0 ;
13862 PyObject * obj0 = 0 ;
13863 PyObject * obj1 = 0 ;
13864 char * kwnames[] = {
13865 (char *) "self",(char *) "textOrientation", NULL
13866 };
13867
13868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13870 if (!SWIG_IsOK(res1)) {
13871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13872 }
13873 arg1 = reinterpret_cast< wxGrid * >(argp1);
13874 ecode2 = SWIG_AsVal_int(obj1, &val2);
13875 if (!SWIG_IsOK(ecode2)) {
13876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13877 }
13878 arg2 = static_cast< int >(val2);
13879 {
13880 PyThreadState* __tstate = wxPyBeginAllowThreads();
13881 (arg1)->SetColLabelTextOrientation(arg2);
13882 wxPyEndAllowThreads(__tstate);
13883 if (PyErr_Occurred()) SWIG_fail;
13884 }
13885 resultobj = SWIG_Py_Void();
13886 return resultobj;
13887 fail:
13888 return NULL;
13889 }
13890
13891
13892 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj = 0;
13894 wxGrid *arg1 = (wxGrid *) 0 ;
13895 int arg2 ;
13896 wxString *arg3 = 0 ;
13897 void *argp1 = 0 ;
13898 int res1 = 0 ;
13899 int val2 ;
13900 int ecode2 = 0 ;
13901 bool temp3 = false ;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "self",(char *) "row",(char *)"arg3", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13911 if (!SWIG_IsOK(res1)) {
13912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13913 }
13914 arg1 = reinterpret_cast< wxGrid * >(argp1);
13915 ecode2 = SWIG_AsVal_int(obj1, &val2);
13916 if (!SWIG_IsOK(ecode2)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13918 }
13919 arg2 = static_cast< int >(val2);
13920 {
13921 arg3 = wxString_in_helper(obj2);
13922 if (arg3 == NULL) SWIG_fail;
13923 temp3 = true;
13924 }
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_Py_Void();
13932 {
13933 if (temp3)
13934 delete arg3;
13935 }
13936 return resultobj;
13937 fail:
13938 {
13939 if (temp3)
13940 delete arg3;
13941 }
13942 return NULL;
13943 }
13944
13945
13946 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13947 PyObject *resultobj = 0;
13948 wxGrid *arg1 = (wxGrid *) 0 ;
13949 int arg2 ;
13950 wxString *arg3 = 0 ;
13951 void *argp1 = 0 ;
13952 int res1 = 0 ;
13953 int val2 ;
13954 int ecode2 = 0 ;
13955 bool temp3 = false ;
13956 PyObject * obj0 = 0 ;
13957 PyObject * obj1 = 0 ;
13958 PyObject * obj2 = 0 ;
13959 char * kwnames[] = {
13960 (char *) "self",(char *) "col",(char *)"arg3", NULL
13961 };
13962
13963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13965 if (!SWIG_IsOK(res1)) {
13966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13967 }
13968 arg1 = reinterpret_cast< wxGrid * >(argp1);
13969 ecode2 = SWIG_AsVal_int(obj1, &val2);
13970 if (!SWIG_IsOK(ecode2)) {
13971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13972 }
13973 arg2 = static_cast< int >(val2);
13974 {
13975 arg3 = wxString_in_helper(obj2);
13976 if (arg3 == NULL) SWIG_fail;
13977 temp3 = true;
13978 }
13979 {
13980 PyThreadState* __tstate = wxPyBeginAllowThreads();
13981 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13982 wxPyEndAllowThreads(__tstate);
13983 if (PyErr_Occurred()) SWIG_fail;
13984 }
13985 resultobj = SWIG_Py_Void();
13986 {
13987 if (temp3)
13988 delete arg3;
13989 }
13990 return resultobj;
13991 fail:
13992 {
13993 if (temp3)
13994 delete arg3;
13995 }
13996 return NULL;
13997 }
13998
13999
14000 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14001 PyObject *resultobj = 0;
14002 wxGrid *arg1 = (wxGrid *) 0 ;
14003 wxColour *arg2 = 0 ;
14004 void *argp1 = 0 ;
14005 int res1 = 0 ;
14006 wxColour temp2 ;
14007 PyObject * obj0 = 0 ;
14008 PyObject * obj1 = 0 ;
14009 char * kwnames[] = {
14010 (char *) "self",(char *)"arg2", NULL
14011 };
14012
14013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",kwnames,&obj0,&obj1)) SWIG_fail;
14014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14015 if (!SWIG_IsOK(res1)) {
14016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14017 }
14018 arg1 = reinterpret_cast< wxGrid * >(argp1);
14019 {
14020 arg2 = &temp2;
14021 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14022 }
14023 {
14024 PyThreadState* __tstate = wxPyBeginAllowThreads();
14025 (arg1)->SetGridLineColour((wxColour const &)*arg2);
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 resultobj = SWIG_Py_Void();
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj = 0;
14038 wxGrid *arg1 = (wxGrid *) 0 ;
14039 wxColour *arg2 = 0 ;
14040 void *argp1 = 0 ;
14041 int res1 = 0 ;
14042 wxColour temp2 ;
14043 PyObject * obj0 = 0 ;
14044 PyObject * obj1 = 0 ;
14045 char * kwnames[] = {
14046 (char *) "self",(char *)"arg2", NULL
14047 };
14048
14049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
14050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14051 if (!SWIG_IsOK(res1)) {
14052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14053 }
14054 arg1 = reinterpret_cast< wxGrid * >(argp1);
14055 {
14056 arg2 = &temp2;
14057 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14058 }
14059 {
14060 PyThreadState* __tstate = wxPyBeginAllowThreads();
14061 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
14062 wxPyEndAllowThreads(__tstate);
14063 if (PyErr_Occurred()) SWIG_fail;
14064 }
14065 resultobj = SWIG_Py_Void();
14066 return resultobj;
14067 fail:
14068 return NULL;
14069 }
14070
14071
14072 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14073 PyObject *resultobj = 0;
14074 wxGrid *arg1 = (wxGrid *) 0 ;
14075 int arg2 ;
14076 void *argp1 = 0 ;
14077 int res1 = 0 ;
14078 int val2 ;
14079 int ecode2 = 0 ;
14080 PyObject * obj0 = 0 ;
14081 PyObject * obj1 = 0 ;
14082 char * kwnames[] = {
14083 (char *) "self",(char *) "width", NULL
14084 };
14085
14086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14088 if (!SWIG_IsOK(res1)) {
14089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14090 }
14091 arg1 = reinterpret_cast< wxGrid * >(argp1);
14092 ecode2 = SWIG_AsVal_int(obj1, &val2);
14093 if (!SWIG_IsOK(ecode2)) {
14094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
14095 }
14096 arg2 = static_cast< int >(val2);
14097 {
14098 PyThreadState* __tstate = wxPyBeginAllowThreads();
14099 (arg1)->SetCellHighlightPenWidth(arg2);
14100 wxPyEndAllowThreads(__tstate);
14101 if (PyErr_Occurred()) SWIG_fail;
14102 }
14103 resultobj = SWIG_Py_Void();
14104 return resultobj;
14105 fail:
14106 return NULL;
14107 }
14108
14109
14110 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14111 PyObject *resultobj = 0;
14112 wxGrid *arg1 = (wxGrid *) 0 ;
14113 int arg2 ;
14114 void *argp1 = 0 ;
14115 int res1 = 0 ;
14116 int val2 ;
14117 int ecode2 = 0 ;
14118 PyObject * obj0 = 0 ;
14119 PyObject * obj1 = 0 ;
14120 char * kwnames[] = {
14121 (char *) "self",(char *) "width", NULL
14122 };
14123
14124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
14125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14126 if (!SWIG_IsOK(res1)) {
14127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
14128 }
14129 arg1 = reinterpret_cast< wxGrid * >(argp1);
14130 ecode2 = SWIG_AsVal_int(obj1, &val2);
14131 if (!SWIG_IsOK(ecode2)) {
14132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
14133 }
14134 arg2 = static_cast< int >(val2);
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 (arg1)->SetCellHighlightROPenWidth(arg2);
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 resultobj = SWIG_Py_Void();
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14149 PyObject *resultobj = 0;
14150 wxGrid *arg1 = (wxGrid *) 0 ;
14151 bool arg2 = (bool) true ;
14152 void *argp1 = 0 ;
14153 int res1 = 0 ;
14154 bool val2 ;
14155 int ecode2 = 0 ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 char * kwnames[] = {
14159 (char *) "self",(char *) "enable", NULL
14160 };
14161
14162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14164 if (!SWIG_IsOK(res1)) {
14165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14166 }
14167 arg1 = reinterpret_cast< wxGrid * >(argp1);
14168 if (obj1) {
14169 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14170 if (!SWIG_IsOK(ecode2)) {
14171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
14172 }
14173 arg2 = static_cast< bool >(val2);
14174 }
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 (arg1)->EnableDragRowSize(arg2);
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 resultobj = SWIG_Py_Void();
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14189 PyObject *resultobj = 0;
14190 wxGrid *arg1 = (wxGrid *) 0 ;
14191 void *argp1 = 0 ;
14192 int res1 = 0 ;
14193 PyObject *swig_obj[1] ;
14194
14195 if (!args) SWIG_fail;
14196 swig_obj[0] = args;
14197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14198 if (!SWIG_IsOK(res1)) {
14199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14200 }
14201 arg1 = reinterpret_cast< wxGrid * >(argp1);
14202 {
14203 PyThreadState* __tstate = wxPyBeginAllowThreads();
14204 (arg1)->DisableDragRowSize();
14205 wxPyEndAllowThreads(__tstate);
14206 if (PyErr_Occurred()) SWIG_fail;
14207 }
14208 resultobj = SWIG_Py_Void();
14209 return resultobj;
14210 fail:
14211 return NULL;
14212 }
14213
14214
14215 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14216 PyObject *resultobj = 0;
14217 wxGrid *arg1 = (wxGrid *) 0 ;
14218 bool result;
14219 void *argp1 = 0 ;
14220 int res1 = 0 ;
14221 PyObject *swig_obj[1] ;
14222
14223 if (!args) SWIG_fail;
14224 swig_obj[0] = args;
14225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14226 if (!SWIG_IsOK(res1)) {
14227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14228 }
14229 arg1 = reinterpret_cast< wxGrid * >(argp1);
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 result = (bool)(arg1)->CanDragRowSize();
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 {
14237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14238 }
14239 return resultobj;
14240 fail:
14241 return NULL;
14242 }
14243
14244
14245 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14246 PyObject *resultobj = 0;
14247 wxGrid *arg1 = (wxGrid *) 0 ;
14248 bool arg2 = (bool) true ;
14249 void *argp1 = 0 ;
14250 int res1 = 0 ;
14251 bool val2 ;
14252 int ecode2 = 0 ;
14253 PyObject * obj0 = 0 ;
14254 PyObject * obj1 = 0 ;
14255 char * kwnames[] = {
14256 (char *) "self",(char *) "enable", NULL
14257 };
14258
14259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14261 if (!SWIG_IsOK(res1)) {
14262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14263 }
14264 arg1 = reinterpret_cast< wxGrid * >(argp1);
14265 if (obj1) {
14266 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14267 if (!SWIG_IsOK(ecode2)) {
14268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
14269 }
14270 arg2 = static_cast< bool >(val2);
14271 }
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 (arg1)->EnableDragColSize(arg2);
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 resultobj = SWIG_Py_Void();
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14286 PyObject *resultobj = 0;
14287 wxGrid *arg1 = (wxGrid *) 0 ;
14288 void *argp1 = 0 ;
14289 int res1 = 0 ;
14290 PyObject *swig_obj[1] ;
14291
14292 if (!args) SWIG_fail;
14293 swig_obj[0] = args;
14294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14295 if (!SWIG_IsOK(res1)) {
14296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14297 }
14298 arg1 = reinterpret_cast< wxGrid * >(argp1);
14299 {
14300 PyThreadState* __tstate = wxPyBeginAllowThreads();
14301 (arg1)->DisableDragColSize();
14302 wxPyEndAllowThreads(__tstate);
14303 if (PyErr_Occurred()) SWIG_fail;
14304 }
14305 resultobj = SWIG_Py_Void();
14306 return resultobj;
14307 fail:
14308 return NULL;
14309 }
14310
14311
14312 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14313 PyObject *resultobj = 0;
14314 wxGrid *arg1 = (wxGrid *) 0 ;
14315 bool result;
14316 void *argp1 = 0 ;
14317 int res1 = 0 ;
14318 PyObject *swig_obj[1] ;
14319
14320 if (!args) SWIG_fail;
14321 swig_obj[0] = args;
14322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14323 if (!SWIG_IsOK(res1)) {
14324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14325 }
14326 arg1 = reinterpret_cast< wxGrid * >(argp1);
14327 {
14328 PyThreadState* __tstate = wxPyBeginAllowThreads();
14329 result = (bool)(arg1)->CanDragColSize();
14330 wxPyEndAllowThreads(__tstate);
14331 if (PyErr_Occurred()) SWIG_fail;
14332 }
14333 {
14334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14335 }
14336 return resultobj;
14337 fail:
14338 return NULL;
14339 }
14340
14341
14342 SWIGINTERN PyObject *_wrap_Grid_EnableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14343 PyObject *resultobj = 0;
14344 wxGrid *arg1 = (wxGrid *) 0 ;
14345 bool arg2 = (bool) true ;
14346 void *argp1 = 0 ;
14347 int res1 = 0 ;
14348 bool val2 ;
14349 int ecode2 = 0 ;
14350 PyObject * obj0 = 0 ;
14351 PyObject * obj1 = 0 ;
14352 char * kwnames[] = {
14353 (char *) "self",(char *) "enable", NULL
14354 };
14355
14356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColMove",kwnames,&obj0,&obj1)) SWIG_fail;
14357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14358 if (!SWIG_IsOK(res1)) {
14359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14360 }
14361 arg1 = reinterpret_cast< wxGrid * >(argp1);
14362 if (obj1) {
14363 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14364 if (!SWIG_IsOK(ecode2)) {
14365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColMove" "', expected argument " "2"" of type '" "bool""'");
14366 }
14367 arg2 = static_cast< bool >(val2);
14368 }
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 (arg1)->EnableDragColMove(arg2);
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 resultobj = SWIG_Py_Void();
14376 return resultobj;
14377 fail:
14378 return NULL;
14379 }
14380
14381
14382 SWIGINTERN PyObject *_wrap_Grid_DisableDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14383 PyObject *resultobj = 0;
14384 wxGrid *arg1 = (wxGrid *) 0 ;
14385 void *argp1 = 0 ;
14386 int res1 = 0 ;
14387 PyObject *swig_obj[1] ;
14388
14389 if (!args) SWIG_fail;
14390 swig_obj[0] = args;
14391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14392 if (!SWIG_IsOK(res1)) {
14393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14394 }
14395 arg1 = reinterpret_cast< wxGrid * >(argp1);
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 (arg1)->DisableDragColMove();
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_Py_Void();
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 SWIGINTERN PyObject *_wrap_Grid_CanDragColMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14410 PyObject *resultobj = 0;
14411 wxGrid *arg1 = (wxGrid *) 0 ;
14412 bool result;
14413 void *argp1 = 0 ;
14414 int res1 = 0 ;
14415 PyObject *swig_obj[1] ;
14416
14417 if (!args) SWIG_fail;
14418 swig_obj[0] = args;
14419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14420 if (!SWIG_IsOK(res1)) {
14421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColMove" "', expected argument " "1"" of type '" "wxGrid *""'");
14422 }
14423 arg1 = reinterpret_cast< wxGrid * >(argp1);
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (bool)(arg1)->CanDragColMove();
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 {
14431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14432 }
14433 return resultobj;
14434 fail:
14435 return NULL;
14436 }
14437
14438
14439 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14440 PyObject *resultobj = 0;
14441 wxGrid *arg1 = (wxGrid *) 0 ;
14442 bool arg2 = (bool) true ;
14443 void *argp1 = 0 ;
14444 int res1 = 0 ;
14445 bool val2 ;
14446 int ecode2 = 0 ;
14447 PyObject * obj0 = 0 ;
14448 PyObject * obj1 = 0 ;
14449 char * kwnames[] = {
14450 (char *) "self",(char *) "enable", NULL
14451 };
14452
14453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
14454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14455 if (!SWIG_IsOK(res1)) {
14456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14457 }
14458 arg1 = reinterpret_cast< wxGrid * >(argp1);
14459 if (obj1) {
14460 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14461 if (!SWIG_IsOK(ecode2)) {
14462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
14463 }
14464 arg2 = static_cast< bool >(val2);
14465 }
14466 {
14467 PyThreadState* __tstate = wxPyBeginAllowThreads();
14468 (arg1)->EnableDragGridSize(arg2);
14469 wxPyEndAllowThreads(__tstate);
14470 if (PyErr_Occurred()) SWIG_fail;
14471 }
14472 resultobj = SWIG_Py_Void();
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14480 PyObject *resultobj = 0;
14481 wxGrid *arg1 = (wxGrid *) 0 ;
14482 void *argp1 = 0 ;
14483 int res1 = 0 ;
14484 PyObject *swig_obj[1] ;
14485
14486 if (!args) SWIG_fail;
14487 swig_obj[0] = args;
14488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14489 if (!SWIG_IsOK(res1)) {
14490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14491 }
14492 arg1 = reinterpret_cast< wxGrid * >(argp1);
14493 {
14494 PyThreadState* __tstate = wxPyBeginAllowThreads();
14495 (arg1)->DisableDragGridSize();
14496 wxPyEndAllowThreads(__tstate);
14497 if (PyErr_Occurred()) SWIG_fail;
14498 }
14499 resultobj = SWIG_Py_Void();
14500 return resultobj;
14501 fail:
14502 return NULL;
14503 }
14504
14505
14506 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14507 PyObject *resultobj = 0;
14508 wxGrid *arg1 = (wxGrid *) 0 ;
14509 bool result;
14510 void *argp1 = 0 ;
14511 int res1 = 0 ;
14512 PyObject *swig_obj[1] ;
14513
14514 if (!args) SWIG_fail;
14515 swig_obj[0] = args;
14516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14517 if (!SWIG_IsOK(res1)) {
14518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14519 }
14520 arg1 = reinterpret_cast< wxGrid * >(argp1);
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (bool)(arg1)->CanDragGridSize();
14524 wxPyEndAllowThreads(__tstate);
14525 if (PyErr_Occurred()) SWIG_fail;
14526 }
14527 {
14528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14529 }
14530 return resultobj;
14531 fail:
14532 return NULL;
14533 }
14534
14535
14536 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj = 0;
14538 wxGrid *arg1 = (wxGrid *) 0 ;
14539 bool arg2 = (bool) true ;
14540 void *argp1 = 0 ;
14541 int res1 = 0 ;
14542 bool val2 ;
14543 int ecode2 = 0 ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 char * kwnames[] = {
14547 (char *) "self",(char *) "enable", NULL
14548 };
14549
14550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14554 }
14555 arg1 = reinterpret_cast< wxGrid * >(argp1);
14556 if (obj1) {
14557 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14558 if (!SWIG_IsOK(ecode2)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14560 }
14561 arg2 = static_cast< bool >(val2);
14562 }
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 (arg1)->EnableDragCell(arg2);
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 resultobj = SWIG_Py_Void();
14570 return resultobj;
14571 fail:
14572 return NULL;
14573 }
14574
14575
14576 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14577 PyObject *resultobj = 0;
14578 wxGrid *arg1 = (wxGrid *) 0 ;
14579 void *argp1 = 0 ;
14580 int res1 = 0 ;
14581 PyObject *swig_obj[1] ;
14582
14583 if (!args) SWIG_fail;
14584 swig_obj[0] = args;
14585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14586 if (!SWIG_IsOK(res1)) {
14587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14588 }
14589 arg1 = reinterpret_cast< wxGrid * >(argp1);
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 (arg1)->DisableDragCell();
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 resultobj = SWIG_Py_Void();
14597 return resultobj;
14598 fail:
14599 return NULL;
14600 }
14601
14602
14603 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14604 PyObject *resultobj = 0;
14605 wxGrid *arg1 = (wxGrid *) 0 ;
14606 bool result;
14607 void *argp1 = 0 ;
14608 int res1 = 0 ;
14609 PyObject *swig_obj[1] ;
14610
14611 if (!args) SWIG_fail;
14612 swig_obj[0] = args;
14613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14614 if (!SWIG_IsOK(res1)) {
14615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14616 }
14617 arg1 = reinterpret_cast< wxGrid * >(argp1);
14618 {
14619 PyThreadState* __tstate = wxPyBeginAllowThreads();
14620 result = (bool)(arg1)->CanDragCell();
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 {
14625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14626 }
14627 return resultobj;
14628 fail:
14629 return NULL;
14630 }
14631
14632
14633 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj = 0;
14635 wxGrid *arg1 = (wxGrid *) 0 ;
14636 int arg2 ;
14637 int arg3 ;
14638 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14639 void *argp1 = 0 ;
14640 int res1 = 0 ;
14641 int val2 ;
14642 int ecode2 = 0 ;
14643 int val3 ;
14644 int ecode3 = 0 ;
14645 void *argp4 = 0 ;
14646 int res4 = 0 ;
14647 PyObject * obj0 = 0 ;
14648 PyObject * obj1 = 0 ;
14649 PyObject * obj2 = 0 ;
14650 PyObject * obj3 = 0 ;
14651 char * kwnames[] = {
14652 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14653 };
14654
14655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14657 if (!SWIG_IsOK(res1)) {
14658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14659 }
14660 arg1 = reinterpret_cast< wxGrid * >(argp1);
14661 ecode2 = SWIG_AsVal_int(obj1, &val2);
14662 if (!SWIG_IsOK(ecode2)) {
14663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14664 }
14665 arg2 = static_cast< int >(val2);
14666 ecode3 = SWIG_AsVal_int(obj2, &val3);
14667 if (!SWIG_IsOK(ecode3)) {
14668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14669 }
14670 arg3 = static_cast< int >(val3);
14671 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14672 if (!SWIG_IsOK(res4)) {
14673 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14674 }
14675 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 (arg1)->SetAttr(arg2,arg3,arg4);
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 resultobj = SWIG_Py_Void();
14683 return resultobj;
14684 fail:
14685 return NULL;
14686 }
14687
14688
14689 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14690 PyObject *resultobj = 0;
14691 wxGrid *arg1 = (wxGrid *) 0 ;
14692 int arg2 ;
14693 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14694 void *argp1 = 0 ;
14695 int res1 = 0 ;
14696 int val2 ;
14697 int ecode2 = 0 ;
14698 void *argp3 = 0 ;
14699 int res3 = 0 ;
14700 PyObject * obj0 = 0 ;
14701 PyObject * obj1 = 0 ;
14702 PyObject * obj2 = 0 ;
14703 char * kwnames[] = {
14704 (char *) "self",(char *) "row",(char *) "attr", NULL
14705 };
14706
14707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14709 if (!SWIG_IsOK(res1)) {
14710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14711 }
14712 arg1 = reinterpret_cast< wxGrid * >(argp1);
14713 ecode2 = SWIG_AsVal_int(obj1, &val2);
14714 if (!SWIG_IsOK(ecode2)) {
14715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14716 }
14717 arg2 = static_cast< int >(val2);
14718 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14719 if (!SWIG_IsOK(res3)) {
14720 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14721 }
14722 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14723 {
14724 PyThreadState* __tstate = wxPyBeginAllowThreads();
14725 (arg1)->SetRowAttr(arg2,arg3);
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 resultobj = SWIG_Py_Void();
14730 return resultobj;
14731 fail:
14732 return NULL;
14733 }
14734
14735
14736 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14737 PyObject *resultobj = 0;
14738 wxGrid *arg1 = (wxGrid *) 0 ;
14739 int arg2 ;
14740 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 int val2 ;
14744 int ecode2 = 0 ;
14745 void *argp3 = 0 ;
14746 int res3 = 0 ;
14747 PyObject * obj0 = 0 ;
14748 PyObject * obj1 = 0 ;
14749 PyObject * obj2 = 0 ;
14750 char * kwnames[] = {
14751 (char *) "self",(char *) "col",(char *) "attr", NULL
14752 };
14753
14754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14756 if (!SWIG_IsOK(res1)) {
14757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14758 }
14759 arg1 = reinterpret_cast< wxGrid * >(argp1);
14760 ecode2 = SWIG_AsVal_int(obj1, &val2);
14761 if (!SWIG_IsOK(ecode2)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14763 }
14764 arg2 = static_cast< int >(val2);
14765 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14766 if (!SWIG_IsOK(res3)) {
14767 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14768 }
14769 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14770 {
14771 PyThreadState* __tstate = wxPyBeginAllowThreads();
14772 (arg1)->SetColAttr(arg2,arg3);
14773 wxPyEndAllowThreads(__tstate);
14774 if (PyErr_Occurred()) SWIG_fail;
14775 }
14776 resultobj = SWIG_Py_Void();
14777 return resultobj;
14778 fail:
14779 return NULL;
14780 }
14781
14782
14783 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14784 PyObject *resultobj = 0;
14785 wxGrid *arg1 = (wxGrid *) 0 ;
14786 int arg2 ;
14787 int arg3 ;
14788 wxGridCellAttr *result = 0 ;
14789 void *argp1 = 0 ;
14790 int res1 = 0 ;
14791 int val2 ;
14792 int ecode2 = 0 ;
14793 int val3 ;
14794 int ecode3 = 0 ;
14795 PyObject * obj0 = 0 ;
14796 PyObject * obj1 = 0 ;
14797 PyObject * obj2 = 0 ;
14798 char * kwnames[] = {
14799 (char *) "self",(char *) "row",(char *) "col", NULL
14800 };
14801
14802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14804 if (!SWIG_IsOK(res1)) {
14805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14806 }
14807 arg1 = reinterpret_cast< wxGrid * >(argp1);
14808 ecode2 = SWIG_AsVal_int(obj1, &val2);
14809 if (!SWIG_IsOK(ecode2)) {
14810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14811 }
14812 arg2 = static_cast< int >(val2);
14813 ecode3 = SWIG_AsVal_int(obj2, &val3);
14814 if (!SWIG_IsOK(ecode3)) {
14815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14816 }
14817 arg3 = static_cast< int >(val3);
14818 {
14819 PyThreadState* __tstate = wxPyBeginAllowThreads();
14820 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14821 wxPyEndAllowThreads(__tstate);
14822 if (PyErr_Occurred()) SWIG_fail;
14823 }
14824 {
14825 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14826 }
14827 return resultobj;
14828 fail:
14829 return NULL;
14830 }
14831
14832
14833 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14834 PyObject *resultobj = 0;
14835 wxGrid *arg1 = (wxGrid *) 0 ;
14836 int arg2 ;
14837 void *argp1 = 0 ;
14838 int res1 = 0 ;
14839 int val2 ;
14840 int ecode2 = 0 ;
14841 PyObject * obj0 = 0 ;
14842 PyObject * obj1 = 0 ;
14843 char * kwnames[] = {
14844 (char *) "self",(char *) "col", NULL
14845 };
14846
14847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14849 if (!SWIG_IsOK(res1)) {
14850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14851 }
14852 arg1 = reinterpret_cast< wxGrid * >(argp1);
14853 ecode2 = SWIG_AsVal_int(obj1, &val2);
14854 if (!SWIG_IsOK(ecode2)) {
14855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14856 }
14857 arg2 = static_cast< int >(val2);
14858 {
14859 PyThreadState* __tstate = wxPyBeginAllowThreads();
14860 (arg1)->SetColFormatBool(arg2);
14861 wxPyEndAllowThreads(__tstate);
14862 if (PyErr_Occurred()) SWIG_fail;
14863 }
14864 resultobj = SWIG_Py_Void();
14865 return resultobj;
14866 fail:
14867 return NULL;
14868 }
14869
14870
14871 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14872 PyObject *resultobj = 0;
14873 wxGrid *arg1 = (wxGrid *) 0 ;
14874 int arg2 ;
14875 void *argp1 = 0 ;
14876 int res1 = 0 ;
14877 int val2 ;
14878 int ecode2 = 0 ;
14879 PyObject * obj0 = 0 ;
14880 PyObject * obj1 = 0 ;
14881 char * kwnames[] = {
14882 (char *) "self",(char *) "col", NULL
14883 };
14884
14885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14887 if (!SWIG_IsOK(res1)) {
14888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14889 }
14890 arg1 = reinterpret_cast< wxGrid * >(argp1);
14891 ecode2 = SWIG_AsVal_int(obj1, &val2);
14892 if (!SWIG_IsOK(ecode2)) {
14893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14894 }
14895 arg2 = static_cast< int >(val2);
14896 {
14897 PyThreadState* __tstate = wxPyBeginAllowThreads();
14898 (arg1)->SetColFormatNumber(arg2);
14899 wxPyEndAllowThreads(__tstate);
14900 if (PyErr_Occurred()) SWIG_fail;
14901 }
14902 resultobj = SWIG_Py_Void();
14903 return resultobj;
14904 fail:
14905 return NULL;
14906 }
14907
14908
14909 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14910 PyObject *resultobj = 0;
14911 wxGrid *arg1 = (wxGrid *) 0 ;
14912 int arg2 ;
14913 int arg3 = (int) -1 ;
14914 int arg4 = (int) -1 ;
14915 void *argp1 = 0 ;
14916 int res1 = 0 ;
14917 int val2 ;
14918 int ecode2 = 0 ;
14919 int val3 ;
14920 int ecode3 = 0 ;
14921 int val4 ;
14922 int ecode4 = 0 ;
14923 PyObject * obj0 = 0 ;
14924 PyObject * obj1 = 0 ;
14925 PyObject * obj2 = 0 ;
14926 PyObject * obj3 = 0 ;
14927 char * kwnames[] = {
14928 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14929 };
14930
14931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14933 if (!SWIG_IsOK(res1)) {
14934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14935 }
14936 arg1 = reinterpret_cast< wxGrid * >(argp1);
14937 ecode2 = SWIG_AsVal_int(obj1, &val2);
14938 if (!SWIG_IsOK(ecode2)) {
14939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14940 }
14941 arg2 = static_cast< int >(val2);
14942 if (obj2) {
14943 ecode3 = SWIG_AsVal_int(obj2, &val3);
14944 if (!SWIG_IsOK(ecode3)) {
14945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14946 }
14947 arg3 = static_cast< int >(val3);
14948 }
14949 if (obj3) {
14950 ecode4 = SWIG_AsVal_int(obj3, &val4);
14951 if (!SWIG_IsOK(ecode4)) {
14952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14953 }
14954 arg4 = static_cast< int >(val4);
14955 }
14956 {
14957 PyThreadState* __tstate = wxPyBeginAllowThreads();
14958 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14959 wxPyEndAllowThreads(__tstate);
14960 if (PyErr_Occurred()) SWIG_fail;
14961 }
14962 resultobj = SWIG_Py_Void();
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14970 PyObject *resultobj = 0;
14971 wxGrid *arg1 = (wxGrid *) 0 ;
14972 int arg2 ;
14973 wxString *arg3 = 0 ;
14974 void *argp1 = 0 ;
14975 int res1 = 0 ;
14976 int val2 ;
14977 int ecode2 = 0 ;
14978 bool temp3 = false ;
14979 PyObject * obj0 = 0 ;
14980 PyObject * obj1 = 0 ;
14981 PyObject * obj2 = 0 ;
14982 char * kwnames[] = {
14983 (char *) "self",(char *) "col",(char *) "typeName", NULL
14984 };
14985
14986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14988 if (!SWIG_IsOK(res1)) {
14989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14990 }
14991 arg1 = reinterpret_cast< wxGrid * >(argp1);
14992 ecode2 = SWIG_AsVal_int(obj1, &val2);
14993 if (!SWIG_IsOK(ecode2)) {
14994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14995 }
14996 arg2 = static_cast< int >(val2);
14997 {
14998 arg3 = wxString_in_helper(obj2);
14999 if (arg3 == NULL) SWIG_fail;
15000 temp3 = true;
15001 }
15002 {
15003 PyThreadState* __tstate = wxPyBeginAllowThreads();
15004 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 resultobj = SWIG_Py_Void();
15009 {
15010 if (temp3)
15011 delete arg3;
15012 }
15013 return resultobj;
15014 fail:
15015 {
15016 if (temp3)
15017 delete arg3;
15018 }
15019 return NULL;
15020 }
15021
15022
15023 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15024 PyObject *resultobj = 0;
15025 wxGrid *arg1 = (wxGrid *) 0 ;
15026 bool arg2 = (bool) true ;
15027 void *argp1 = 0 ;
15028 int res1 = 0 ;
15029 bool val2 ;
15030 int ecode2 = 0 ;
15031 PyObject * obj0 = 0 ;
15032 PyObject * obj1 = 0 ;
15033 char * kwnames[] = {
15034 (char *) "self",(char *) "enable", NULL
15035 };
15036
15037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableGridLines",kwnames,&obj0,&obj1)) SWIG_fail;
15038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15039 if (!SWIG_IsOK(res1)) {
15040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableGridLines" "', expected argument " "1"" of type '" "wxGrid *""'");
15041 }
15042 arg1 = reinterpret_cast< wxGrid * >(argp1);
15043 if (obj1) {
15044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15045 if (!SWIG_IsOK(ecode2)) {
15046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
15047 }
15048 arg2 = static_cast< bool >(val2);
15049 }
15050 {
15051 PyThreadState* __tstate = wxPyBeginAllowThreads();
15052 (arg1)->EnableGridLines(arg2);
15053 wxPyEndAllowThreads(__tstate);
15054 if (PyErr_Occurred()) SWIG_fail;
15055 }
15056 resultobj = SWIG_Py_Void();
15057 return resultobj;
15058 fail:
15059 return NULL;
15060 }
15061
15062
15063 SWIGINTERN PyObject *_wrap_Grid_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15064 PyObject *resultobj = 0;
15065 wxGrid *arg1 = (wxGrid *) 0 ;
15066 bool result;
15067 void *argp1 = 0 ;
15068 int res1 = 0 ;
15069 PyObject *swig_obj[1] ;
15070
15071 if (!args) SWIG_fail;
15072 swig_obj[0] = args;
15073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15074 if (!SWIG_IsOK(res1)) {
15075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
15076 }
15077 arg1 = reinterpret_cast< wxGrid * >(argp1);
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = (bool)(arg1)->GridLinesEnabled();
15081 wxPyEndAllowThreads(__tstate);
15082 if (PyErr_Occurred()) SWIG_fail;
15083 }
15084 {
15085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15086 }
15087 return resultobj;
15088 fail:
15089 return NULL;
15090 }
15091
15092
15093 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15094 PyObject *resultobj = 0;
15095 wxGrid *arg1 = (wxGrid *) 0 ;
15096 int result;
15097 void *argp1 = 0 ;
15098 int res1 = 0 ;
15099 PyObject *swig_obj[1] ;
15100
15101 if (!args) SWIG_fail;
15102 swig_obj[0] = args;
15103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15104 if (!SWIG_IsOK(res1)) {
15105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15106 }
15107 arg1 = reinterpret_cast< wxGrid * >(argp1);
15108 {
15109 PyThreadState* __tstate = wxPyBeginAllowThreads();
15110 result = (int)(arg1)->GetDefaultRowSize();
15111 wxPyEndAllowThreads(__tstate);
15112 if (PyErr_Occurred()) SWIG_fail;
15113 }
15114 resultobj = SWIG_From_int(static_cast< int >(result));
15115 return resultobj;
15116 fail:
15117 return NULL;
15118 }
15119
15120
15121 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15122 PyObject *resultobj = 0;
15123 wxGrid *arg1 = (wxGrid *) 0 ;
15124 int arg2 ;
15125 int result;
15126 void *argp1 = 0 ;
15127 int res1 = 0 ;
15128 int val2 ;
15129 int ecode2 = 0 ;
15130 PyObject * obj0 = 0 ;
15131 PyObject * obj1 = 0 ;
15132 char * kwnames[] = {
15133 (char *) "self",(char *) "row", NULL
15134 };
15135
15136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
15137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15138 if (!SWIG_IsOK(res1)) {
15139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15140 }
15141 arg1 = reinterpret_cast< wxGrid * >(argp1);
15142 ecode2 = SWIG_AsVal_int(obj1, &val2);
15143 if (!SWIG_IsOK(ecode2)) {
15144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
15145 }
15146 arg2 = static_cast< int >(val2);
15147 {
15148 PyThreadState* __tstate = wxPyBeginAllowThreads();
15149 result = (int)(arg1)->GetRowSize(arg2);
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 resultobj = SWIG_From_int(static_cast< int >(result));
15154 return resultobj;
15155 fail:
15156 return NULL;
15157 }
15158
15159
15160 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15161 PyObject *resultobj = 0;
15162 wxGrid *arg1 = (wxGrid *) 0 ;
15163 int result;
15164 void *argp1 = 0 ;
15165 int res1 = 0 ;
15166 PyObject *swig_obj[1] ;
15167
15168 if (!args) SWIG_fail;
15169 swig_obj[0] = args;
15170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15171 if (!SWIG_IsOK(res1)) {
15172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15173 }
15174 arg1 = reinterpret_cast< wxGrid * >(argp1);
15175 {
15176 PyThreadState* __tstate = wxPyBeginAllowThreads();
15177 result = (int)(arg1)->GetDefaultColSize();
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 resultobj = SWIG_From_int(static_cast< int >(result));
15182 return resultobj;
15183 fail:
15184 return NULL;
15185 }
15186
15187
15188 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15189 PyObject *resultobj = 0;
15190 wxGrid *arg1 = (wxGrid *) 0 ;
15191 int arg2 ;
15192 int result;
15193 void *argp1 = 0 ;
15194 int res1 = 0 ;
15195 int val2 ;
15196 int ecode2 = 0 ;
15197 PyObject * obj0 = 0 ;
15198 PyObject * obj1 = 0 ;
15199 char * kwnames[] = {
15200 (char *) "self",(char *) "col", NULL
15201 };
15202
15203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
15204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15205 if (!SWIG_IsOK(res1)) {
15206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15207 }
15208 arg1 = reinterpret_cast< wxGrid * >(argp1);
15209 ecode2 = SWIG_AsVal_int(obj1, &val2);
15210 if (!SWIG_IsOK(ecode2)) {
15211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
15212 }
15213 arg2 = static_cast< int >(val2);
15214 {
15215 PyThreadState* __tstate = wxPyBeginAllowThreads();
15216 result = (int)(arg1)->GetColSize(arg2);
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 resultobj = SWIG_From_int(static_cast< int >(result));
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15228 PyObject *resultobj = 0;
15229 wxGrid *arg1 = (wxGrid *) 0 ;
15230 wxColour result;
15231 void *argp1 = 0 ;
15232 int res1 = 0 ;
15233 PyObject *swig_obj[1] ;
15234
15235 if (!args) SWIG_fail;
15236 swig_obj[0] = args;
15237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15238 if (!SWIG_IsOK(res1)) {
15239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15240 }
15241 arg1 = reinterpret_cast< wxGrid * >(argp1);
15242 {
15243 PyThreadState* __tstate = wxPyBeginAllowThreads();
15244 result = (arg1)->GetDefaultCellBackgroundColour();
15245 wxPyEndAllowThreads(__tstate);
15246 if (PyErr_Occurred()) SWIG_fail;
15247 }
15248 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15249 return resultobj;
15250 fail:
15251 return NULL;
15252 }
15253
15254
15255 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15256 PyObject *resultobj = 0;
15257 wxGrid *arg1 = (wxGrid *) 0 ;
15258 int arg2 ;
15259 int arg3 ;
15260 wxColour result;
15261 void *argp1 = 0 ;
15262 int res1 = 0 ;
15263 int val2 ;
15264 int ecode2 = 0 ;
15265 int val3 ;
15266 int ecode3 = 0 ;
15267 PyObject * obj0 = 0 ;
15268 PyObject * obj1 = 0 ;
15269 PyObject * obj2 = 0 ;
15270 char * kwnames[] = {
15271 (char *) "self",(char *) "row",(char *) "col", NULL
15272 };
15273
15274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15276 if (!SWIG_IsOK(res1)) {
15277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15278 }
15279 arg1 = reinterpret_cast< wxGrid * >(argp1);
15280 ecode2 = SWIG_AsVal_int(obj1, &val2);
15281 if (!SWIG_IsOK(ecode2)) {
15282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15283 }
15284 arg2 = static_cast< int >(val2);
15285 ecode3 = SWIG_AsVal_int(obj2, &val3);
15286 if (!SWIG_IsOK(ecode3)) {
15287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15288 }
15289 arg3 = static_cast< int >(val3);
15290 {
15291 PyThreadState* __tstate = wxPyBeginAllowThreads();
15292 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
15293 wxPyEndAllowThreads(__tstate);
15294 if (PyErr_Occurred()) SWIG_fail;
15295 }
15296 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15304 PyObject *resultobj = 0;
15305 wxGrid *arg1 = (wxGrid *) 0 ;
15306 wxColour result;
15307 void *argp1 = 0 ;
15308 int res1 = 0 ;
15309 PyObject *swig_obj[1] ;
15310
15311 if (!args) SWIG_fail;
15312 swig_obj[0] = args;
15313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15314 if (!SWIG_IsOK(res1)) {
15315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15316 }
15317 arg1 = reinterpret_cast< wxGrid * >(argp1);
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (arg1)->GetDefaultCellTextColour();
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15325 return resultobj;
15326 fail:
15327 return NULL;
15328 }
15329
15330
15331 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15332 PyObject *resultobj = 0;
15333 wxGrid *arg1 = (wxGrid *) 0 ;
15334 int arg2 ;
15335 int arg3 ;
15336 wxColour result;
15337 void *argp1 = 0 ;
15338 int res1 = 0 ;
15339 int val2 ;
15340 int ecode2 = 0 ;
15341 int val3 ;
15342 int ecode3 = 0 ;
15343 PyObject * obj0 = 0 ;
15344 PyObject * obj1 = 0 ;
15345 PyObject * obj2 = 0 ;
15346 char * kwnames[] = {
15347 (char *) "self",(char *) "row",(char *) "col", NULL
15348 };
15349
15350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15352 if (!SWIG_IsOK(res1)) {
15353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15354 }
15355 arg1 = reinterpret_cast< wxGrid * >(argp1);
15356 ecode2 = SWIG_AsVal_int(obj1, &val2);
15357 if (!SWIG_IsOK(ecode2)) {
15358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
15359 }
15360 arg2 = static_cast< int >(val2);
15361 ecode3 = SWIG_AsVal_int(obj2, &val3);
15362 if (!SWIG_IsOK(ecode3)) {
15363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
15364 }
15365 arg3 = static_cast< int >(val3);
15366 {
15367 PyThreadState* __tstate = wxPyBeginAllowThreads();
15368 result = (arg1)->GetCellTextColour(arg2,arg3);
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15380 PyObject *resultobj = 0;
15381 wxGrid *arg1 = (wxGrid *) 0 ;
15382 wxFont result;
15383 void *argp1 = 0 ;
15384 int res1 = 0 ;
15385 PyObject *swig_obj[1] ;
15386
15387 if (!args) SWIG_fail;
15388 swig_obj[0] = args;
15389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15390 if (!SWIG_IsOK(res1)) {
15391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15392 }
15393 arg1 = reinterpret_cast< wxGrid * >(argp1);
15394 {
15395 PyThreadState* __tstate = wxPyBeginAllowThreads();
15396 result = (arg1)->GetDefaultCellFont();
15397 wxPyEndAllowThreads(__tstate);
15398 if (PyErr_Occurred()) SWIG_fail;
15399 }
15400 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15401 return resultobj;
15402 fail:
15403 return NULL;
15404 }
15405
15406
15407 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15408 PyObject *resultobj = 0;
15409 wxGrid *arg1 = (wxGrid *) 0 ;
15410 int arg2 ;
15411 int arg3 ;
15412 wxFont result;
15413 void *argp1 = 0 ;
15414 int res1 = 0 ;
15415 int val2 ;
15416 int ecode2 = 0 ;
15417 int val3 ;
15418 int ecode3 = 0 ;
15419 PyObject * obj0 = 0 ;
15420 PyObject * obj1 = 0 ;
15421 PyObject * obj2 = 0 ;
15422 char * kwnames[] = {
15423 (char *) "self",(char *) "row",(char *) "col", NULL
15424 };
15425
15426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15428 if (!SWIG_IsOK(res1)) {
15429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
15430 }
15431 arg1 = reinterpret_cast< wxGrid * >(argp1);
15432 ecode2 = SWIG_AsVal_int(obj1, &val2);
15433 if (!SWIG_IsOK(ecode2)) {
15434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
15435 }
15436 arg2 = static_cast< int >(val2);
15437 ecode3 = SWIG_AsVal_int(obj2, &val3);
15438 if (!SWIG_IsOK(ecode3)) {
15439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
15440 }
15441 arg3 = static_cast< int >(val3);
15442 {
15443 PyThreadState* __tstate = wxPyBeginAllowThreads();
15444 result = (arg1)->GetCellFont(arg2,arg3);
15445 wxPyEndAllowThreads(__tstate);
15446 if (PyErr_Occurred()) SWIG_fail;
15447 }
15448 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
15449 return resultobj;
15450 fail:
15451 return NULL;
15452 }
15453
15454
15455 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15456 PyObject *resultobj = 0;
15457 wxGrid *arg1 = (wxGrid *) 0 ;
15458 int *arg2 = (int *) 0 ;
15459 int *arg3 = (int *) 0 ;
15460 void *argp1 = 0 ;
15461 int res1 = 0 ;
15462 int temp2 ;
15463 int res2 = SWIG_TMPOBJ ;
15464 int temp3 ;
15465 int res3 = SWIG_TMPOBJ ;
15466 PyObject *swig_obj[1] ;
15467
15468 arg2 = &temp2;
15469 arg3 = &temp3;
15470 if (!args) SWIG_fail;
15471 swig_obj[0] = args;
15472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15473 if (!SWIG_IsOK(res1)) {
15474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15475 }
15476 arg1 = reinterpret_cast< wxGrid * >(argp1);
15477 {
15478 PyThreadState* __tstate = wxPyBeginAllowThreads();
15479 (arg1)->GetDefaultCellAlignment(arg2,arg3);
15480 wxPyEndAllowThreads(__tstate);
15481 if (PyErr_Occurred()) SWIG_fail;
15482 }
15483 resultobj = SWIG_Py_Void();
15484 if (SWIG_IsTmpObj(res2)) {
15485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
15486 } else {
15487 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15489 }
15490 if (SWIG_IsTmpObj(res3)) {
15491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15492 } else {
15493 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15495 }
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15503 PyObject *resultobj = 0;
15504 wxGrid *arg1 = (wxGrid *) 0 ;
15505 int arg2 ;
15506 int arg3 ;
15507 int *arg4 = (int *) 0 ;
15508 int *arg5 = (int *) 0 ;
15509 void *argp1 = 0 ;
15510 int res1 = 0 ;
15511 int val2 ;
15512 int ecode2 = 0 ;
15513 int val3 ;
15514 int ecode3 = 0 ;
15515 int temp4 ;
15516 int res4 = SWIG_TMPOBJ ;
15517 int temp5 ;
15518 int res5 = SWIG_TMPOBJ ;
15519 PyObject * obj0 = 0 ;
15520 PyObject * obj1 = 0 ;
15521 PyObject * obj2 = 0 ;
15522 char * kwnames[] = {
15523 (char *) "self",(char *) "row",(char *) "col", NULL
15524 };
15525
15526 arg4 = &temp4;
15527 arg5 = &temp5;
15528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15530 if (!SWIG_IsOK(res1)) {
15531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15532 }
15533 arg1 = reinterpret_cast< wxGrid * >(argp1);
15534 ecode2 = SWIG_AsVal_int(obj1, &val2);
15535 if (!SWIG_IsOK(ecode2)) {
15536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15537 }
15538 arg2 = static_cast< int >(val2);
15539 ecode3 = SWIG_AsVal_int(obj2, &val3);
15540 if (!SWIG_IsOK(ecode3)) {
15541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15542 }
15543 arg3 = static_cast< int >(val3);
15544 {
15545 PyThreadState* __tstate = wxPyBeginAllowThreads();
15546 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 resultobj = SWIG_Py_Void();
15551 if (SWIG_IsTmpObj(res4)) {
15552 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15553 } else {
15554 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15556 }
15557 if (SWIG_IsTmpObj(res5)) {
15558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15559 } else {
15560 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15562 }
15563 return resultobj;
15564 fail:
15565 return NULL;
15566 }
15567
15568
15569 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15570 PyObject *resultobj = 0;
15571 wxGrid *arg1 = (wxGrid *) 0 ;
15572 bool result;
15573 void *argp1 = 0 ;
15574 int res1 = 0 ;
15575 PyObject *swig_obj[1] ;
15576
15577 if (!args) SWIG_fail;
15578 swig_obj[0] = args;
15579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15580 if (!SWIG_IsOK(res1)) {
15581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15582 }
15583 arg1 = reinterpret_cast< wxGrid * >(argp1);
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (bool)(arg1)->GetDefaultCellOverflow();
15587 wxPyEndAllowThreads(__tstate);
15588 if (PyErr_Occurred()) SWIG_fail;
15589 }
15590 {
15591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15592 }
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15600 PyObject *resultobj = 0;
15601 wxGrid *arg1 = (wxGrid *) 0 ;
15602 int arg2 ;
15603 int arg3 ;
15604 bool result;
15605 void *argp1 = 0 ;
15606 int res1 = 0 ;
15607 int val2 ;
15608 int ecode2 = 0 ;
15609 int val3 ;
15610 int ecode3 = 0 ;
15611 PyObject * obj0 = 0 ;
15612 PyObject * obj1 = 0 ;
15613 PyObject * obj2 = 0 ;
15614 char * kwnames[] = {
15615 (char *) "self",(char *) "row",(char *) "col", NULL
15616 };
15617
15618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15620 if (!SWIG_IsOK(res1)) {
15621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15622 }
15623 arg1 = reinterpret_cast< wxGrid * >(argp1);
15624 ecode2 = SWIG_AsVal_int(obj1, &val2);
15625 if (!SWIG_IsOK(ecode2)) {
15626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15627 }
15628 arg2 = static_cast< int >(val2);
15629 ecode3 = SWIG_AsVal_int(obj2, &val3);
15630 if (!SWIG_IsOK(ecode3)) {
15631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15632 }
15633 arg3 = static_cast< int >(val3);
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 {
15641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15642 }
15643 return resultobj;
15644 fail:
15645 return NULL;
15646 }
15647
15648
15649 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15650 PyObject *resultobj = 0;
15651 wxGrid *arg1 = (wxGrid *) 0 ;
15652 int arg2 ;
15653 int arg3 ;
15654 int *arg4 = (int *) 0 ;
15655 int *arg5 = (int *) 0 ;
15656 void *argp1 = 0 ;
15657 int res1 = 0 ;
15658 int val2 ;
15659 int ecode2 = 0 ;
15660 int val3 ;
15661 int ecode3 = 0 ;
15662 int temp4 ;
15663 int res4 = SWIG_TMPOBJ ;
15664 int temp5 ;
15665 int res5 = SWIG_TMPOBJ ;
15666 PyObject * obj0 = 0 ;
15667 PyObject * obj1 = 0 ;
15668 PyObject * obj2 = 0 ;
15669 char * kwnames[] = {
15670 (char *) "self",(char *) "row",(char *) "col", NULL
15671 };
15672
15673 arg4 = &temp4;
15674 arg5 = &temp5;
15675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15677 if (!SWIG_IsOK(res1)) {
15678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15679 }
15680 arg1 = reinterpret_cast< wxGrid * >(argp1);
15681 ecode2 = SWIG_AsVal_int(obj1, &val2);
15682 if (!SWIG_IsOK(ecode2)) {
15683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15684 }
15685 arg2 = static_cast< int >(val2);
15686 ecode3 = SWIG_AsVal_int(obj2, &val3);
15687 if (!SWIG_IsOK(ecode3)) {
15688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15689 }
15690 arg3 = static_cast< int >(val3);
15691 {
15692 PyThreadState* __tstate = wxPyBeginAllowThreads();
15693 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 resultobj = SWIG_Py_Void();
15698 if (SWIG_IsTmpObj(res4)) {
15699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15700 } else {
15701 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15703 }
15704 if (SWIG_IsTmpObj(res5)) {
15705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15706 } else {
15707 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15709 }
15710 return resultobj;
15711 fail:
15712 return NULL;
15713 }
15714
15715
15716 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15717 PyObject *resultobj = 0;
15718 wxGrid *arg1 = (wxGrid *) 0 ;
15719 int arg2 ;
15720 bool arg3 = (bool) false ;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 int val2 ;
15724 int ecode2 = 0 ;
15725 bool val3 ;
15726 int ecode3 = 0 ;
15727 PyObject * obj0 = 0 ;
15728 PyObject * obj1 = 0 ;
15729 PyObject * obj2 = 0 ;
15730 char * kwnames[] = {
15731 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15732 };
15733
15734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15736 if (!SWIG_IsOK(res1)) {
15737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15738 }
15739 arg1 = reinterpret_cast< wxGrid * >(argp1);
15740 ecode2 = SWIG_AsVal_int(obj1, &val2);
15741 if (!SWIG_IsOK(ecode2)) {
15742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15743 }
15744 arg2 = static_cast< int >(val2);
15745 if (obj2) {
15746 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15747 if (!SWIG_IsOK(ecode3)) {
15748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15749 }
15750 arg3 = static_cast< bool >(val3);
15751 }
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 (arg1)->SetDefaultRowSize(arg2,arg3);
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_Py_Void();
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15766 PyObject *resultobj = 0;
15767 wxGrid *arg1 = (wxGrid *) 0 ;
15768 int arg2 ;
15769 int arg3 ;
15770 void *argp1 = 0 ;
15771 int res1 = 0 ;
15772 int val2 ;
15773 int ecode2 = 0 ;
15774 int val3 ;
15775 int ecode3 = 0 ;
15776 PyObject * obj0 = 0 ;
15777 PyObject * obj1 = 0 ;
15778 PyObject * obj2 = 0 ;
15779 char * kwnames[] = {
15780 (char *) "self",(char *) "row",(char *) "height", NULL
15781 };
15782
15783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15785 if (!SWIG_IsOK(res1)) {
15786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15787 }
15788 arg1 = reinterpret_cast< wxGrid * >(argp1);
15789 ecode2 = SWIG_AsVal_int(obj1, &val2);
15790 if (!SWIG_IsOK(ecode2)) {
15791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15792 }
15793 arg2 = static_cast< int >(val2);
15794 ecode3 = SWIG_AsVal_int(obj2, &val3);
15795 if (!SWIG_IsOK(ecode3)) {
15796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15797 }
15798 arg3 = static_cast< int >(val3);
15799 {
15800 PyThreadState* __tstate = wxPyBeginAllowThreads();
15801 (arg1)->SetRowSize(arg2,arg3);
15802 wxPyEndAllowThreads(__tstate);
15803 if (PyErr_Occurred()) SWIG_fail;
15804 }
15805 resultobj = SWIG_Py_Void();
15806 return resultobj;
15807 fail:
15808 return NULL;
15809 }
15810
15811
15812 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15813 PyObject *resultobj = 0;
15814 wxGrid *arg1 = (wxGrid *) 0 ;
15815 int arg2 ;
15816 bool arg3 = (bool) false ;
15817 void *argp1 = 0 ;
15818 int res1 = 0 ;
15819 int val2 ;
15820 int ecode2 = 0 ;
15821 bool val3 ;
15822 int ecode3 = 0 ;
15823 PyObject * obj0 = 0 ;
15824 PyObject * obj1 = 0 ;
15825 PyObject * obj2 = 0 ;
15826 char * kwnames[] = {
15827 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15828 };
15829
15830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15834 }
15835 arg1 = reinterpret_cast< wxGrid * >(argp1);
15836 ecode2 = SWIG_AsVal_int(obj1, &val2);
15837 if (!SWIG_IsOK(ecode2)) {
15838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15839 }
15840 arg2 = static_cast< int >(val2);
15841 if (obj2) {
15842 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15843 if (!SWIG_IsOK(ecode3)) {
15844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15845 }
15846 arg3 = static_cast< bool >(val3);
15847 }
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 (arg1)->SetDefaultColSize(arg2,arg3);
15851 wxPyEndAllowThreads(__tstate);
15852 if (PyErr_Occurred()) SWIG_fail;
15853 }
15854 resultobj = SWIG_Py_Void();
15855 return resultobj;
15856 fail:
15857 return NULL;
15858 }
15859
15860
15861 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15862 PyObject *resultobj = 0;
15863 wxGrid *arg1 = (wxGrid *) 0 ;
15864 int arg2 ;
15865 int arg3 ;
15866 void *argp1 = 0 ;
15867 int res1 = 0 ;
15868 int val2 ;
15869 int ecode2 = 0 ;
15870 int val3 ;
15871 int ecode3 = 0 ;
15872 PyObject * obj0 = 0 ;
15873 PyObject * obj1 = 0 ;
15874 PyObject * obj2 = 0 ;
15875 char * kwnames[] = {
15876 (char *) "self",(char *) "col",(char *) "width", NULL
15877 };
15878
15879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15881 if (!SWIG_IsOK(res1)) {
15882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15883 }
15884 arg1 = reinterpret_cast< wxGrid * >(argp1);
15885 ecode2 = SWIG_AsVal_int(obj1, &val2);
15886 if (!SWIG_IsOK(ecode2)) {
15887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15888 }
15889 arg2 = static_cast< int >(val2);
15890 ecode3 = SWIG_AsVal_int(obj2, &val3);
15891 if (!SWIG_IsOK(ecode3)) {
15892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15893 }
15894 arg3 = static_cast< int >(val3);
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 (arg1)->SetColSize(arg2,arg3);
15898 wxPyEndAllowThreads(__tstate);
15899 if (PyErr_Occurred()) SWIG_fail;
15900 }
15901 resultobj = SWIG_Py_Void();
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 SWIGINTERN PyObject *_wrap_Grid_GetColAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15909 PyObject *resultobj = 0;
15910 wxGrid *arg1 = (wxGrid *) 0 ;
15911 int arg2 ;
15912 int result;
15913 void *argp1 = 0 ;
15914 int res1 = 0 ;
15915 int val2 ;
15916 int ecode2 = 0 ;
15917 PyObject * obj0 = 0 ;
15918 PyObject * obj1 = 0 ;
15919 char * kwnames[] = {
15920 (char *) "self",(char *) "colPos", NULL
15921 };
15922
15923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColAt",kwnames,&obj0,&obj1)) SWIG_fail;
15924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15925 if (!SWIG_IsOK(res1)) {
15926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColAt" "', expected argument " "1"" of type '" "wxGrid const *""'");
15927 }
15928 arg1 = reinterpret_cast< wxGrid * >(argp1);
15929 ecode2 = SWIG_AsVal_int(obj1, &val2);
15930 if (!SWIG_IsOK(ecode2)) {
15931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColAt" "', expected argument " "2"" of type '" "int""'");
15932 }
15933 arg2 = static_cast< int >(val2);
15934 {
15935 PyThreadState* __tstate = wxPyBeginAllowThreads();
15936 result = (int)((wxGrid const *)arg1)->GetColAt(arg2);
15937 wxPyEndAllowThreads(__tstate);
15938 if (PyErr_Occurred()) SWIG_fail;
15939 }
15940 resultobj = SWIG_From_int(static_cast< int >(result));
15941 return resultobj;
15942 fail:
15943 return NULL;
15944 }
15945
15946
15947 SWIGINTERN PyObject *_wrap_Grid_SetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15948 PyObject *resultobj = 0;
15949 wxGrid *arg1 = (wxGrid *) 0 ;
15950 int arg2 ;
15951 int arg3 ;
15952 void *argp1 = 0 ;
15953 int res1 = 0 ;
15954 int val2 ;
15955 int ecode2 = 0 ;
15956 int val3 ;
15957 int ecode3 = 0 ;
15958 PyObject * obj0 = 0 ;
15959 PyObject * obj1 = 0 ;
15960 PyObject * obj2 = 0 ;
15961 char * kwnames[] = {
15962 (char *) "self",(char *) "colID",(char *) "newPos", NULL
15963 };
15964
15965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15967 if (!SWIG_IsOK(res1)) {
15968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColPos" "', expected argument " "1"" of type '" "wxGrid *""'");
15969 }
15970 arg1 = reinterpret_cast< wxGrid * >(argp1);
15971 ecode2 = SWIG_AsVal_int(obj1, &val2);
15972 if (!SWIG_IsOK(ecode2)) {
15973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColPos" "', expected argument " "2"" of type '" "int""'");
15974 }
15975 arg2 = static_cast< int >(val2);
15976 ecode3 = SWIG_AsVal_int(obj2, &val3);
15977 if (!SWIG_IsOK(ecode3)) {
15978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColPos" "', expected argument " "3"" of type '" "int""'");
15979 }
15980 arg3 = static_cast< int >(val3);
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 (arg1)->SetColPos(arg2,arg3);
15984 wxPyEndAllowThreads(__tstate);
15985 if (PyErr_Occurred()) SWIG_fail;
15986 }
15987 resultobj = SWIG_Py_Void();
15988 return resultobj;
15989 fail:
15990 return NULL;
15991 }
15992
15993
15994 SWIGINTERN PyObject *_wrap_Grid_GetColPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15995 PyObject *resultobj = 0;
15996 wxGrid *arg1 = (wxGrid *) 0 ;
15997 int arg2 ;
15998 int result;
15999 void *argp1 = 0 ;
16000 int res1 = 0 ;
16001 int val2 ;
16002 int ecode2 = 0 ;
16003 PyObject * obj0 = 0 ;
16004 PyObject * obj1 = 0 ;
16005 char * kwnames[] = {
16006 (char *) "self",(char *) "colID", NULL
16007 };
16008
16009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColPos",kwnames,&obj0,&obj1)) SWIG_fail;
16010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16011 if (!SWIG_IsOK(res1)) {
16012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColPos" "', expected argument " "1"" of type '" "wxGrid const *""'");
16013 }
16014 arg1 = reinterpret_cast< wxGrid * >(argp1);
16015 ecode2 = SWIG_AsVal_int(obj1, &val2);
16016 if (!SWIG_IsOK(ecode2)) {
16017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColPos" "', expected argument " "2"" of type '" "int""'");
16018 }
16019 arg2 = static_cast< int >(val2);
16020 {
16021 PyThreadState* __tstate = wxPyBeginAllowThreads();
16022 result = (int)((wxGrid const *)arg1)->GetColPos(arg2);
16023 wxPyEndAllowThreads(__tstate);
16024 if (PyErr_Occurred()) SWIG_fail;
16025 }
16026 resultobj = SWIG_From_int(static_cast< int >(result));
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj = 0;
16035 wxGrid *arg1 = (wxGrid *) 0 ;
16036 int arg2 ;
16037 bool arg3 = (bool) true ;
16038 void *argp1 = 0 ;
16039 int res1 = 0 ;
16040 int val2 ;
16041 int ecode2 = 0 ;
16042 bool val3 ;
16043 int ecode3 = 0 ;
16044 PyObject * obj0 = 0 ;
16045 PyObject * obj1 = 0 ;
16046 PyObject * obj2 = 0 ;
16047 char * kwnames[] = {
16048 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
16049 };
16050
16051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16053 if (!SWIG_IsOK(res1)) {
16054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
16055 }
16056 arg1 = reinterpret_cast< wxGrid * >(argp1);
16057 ecode2 = SWIG_AsVal_int(obj1, &val2);
16058 if (!SWIG_IsOK(ecode2)) {
16059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
16060 }
16061 arg2 = static_cast< int >(val2);
16062 if (obj2) {
16063 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16064 if (!SWIG_IsOK(ecode3)) {
16065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
16066 }
16067 arg3 = static_cast< bool >(val3);
16068 }
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 (arg1)->AutoSizeColumn(arg2,arg3);
16072 wxPyEndAllowThreads(__tstate);
16073 if (PyErr_Occurred()) SWIG_fail;
16074 }
16075 resultobj = SWIG_Py_Void();
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16083 PyObject *resultobj = 0;
16084 wxGrid *arg1 = (wxGrid *) 0 ;
16085 int arg2 ;
16086 bool arg3 = (bool) true ;
16087 void *argp1 = 0 ;
16088 int res1 = 0 ;
16089 int val2 ;
16090 int ecode2 = 0 ;
16091 bool val3 ;
16092 int ecode3 = 0 ;
16093 PyObject * obj0 = 0 ;
16094 PyObject * obj1 = 0 ;
16095 PyObject * obj2 = 0 ;
16096 char * kwnames[] = {
16097 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
16098 };
16099
16100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16102 if (!SWIG_IsOK(res1)) {
16103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
16104 }
16105 arg1 = reinterpret_cast< wxGrid * >(argp1);
16106 ecode2 = SWIG_AsVal_int(obj1, &val2);
16107 if (!SWIG_IsOK(ecode2)) {
16108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
16109 }
16110 arg2 = static_cast< int >(val2);
16111 if (obj2) {
16112 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16113 if (!SWIG_IsOK(ecode3)) {
16114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
16115 }
16116 arg3 = static_cast< bool >(val3);
16117 }
16118 {
16119 PyThreadState* __tstate = wxPyBeginAllowThreads();
16120 (arg1)->AutoSizeRow(arg2,arg3);
16121 wxPyEndAllowThreads(__tstate);
16122 if (PyErr_Occurred()) SWIG_fail;
16123 }
16124 resultobj = SWIG_Py_Void();
16125 return resultobj;
16126 fail:
16127 return NULL;
16128 }
16129
16130
16131 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16132 PyObject *resultobj = 0;
16133 wxGrid *arg1 = (wxGrid *) 0 ;
16134 bool arg2 = (bool) true ;
16135 void *argp1 = 0 ;
16136 int res1 = 0 ;
16137 bool val2 ;
16138 int ecode2 = 0 ;
16139 PyObject * obj0 = 0 ;
16140 PyObject * obj1 = 0 ;
16141 char * kwnames[] = {
16142 (char *) "self",(char *) "setAsMin", NULL
16143 };
16144
16145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
16146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16147 if (!SWIG_IsOK(res1)) {
16148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
16149 }
16150 arg1 = reinterpret_cast< wxGrid * >(argp1);
16151 if (obj1) {
16152 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16153 if (!SWIG_IsOK(ecode2)) {
16154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
16155 }
16156 arg2 = static_cast< bool >(val2);
16157 }
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 (arg1)->AutoSizeColumns(arg2);
16161 wxPyEndAllowThreads(__tstate);
16162 if (PyErr_Occurred()) SWIG_fail;
16163 }
16164 resultobj = SWIG_Py_Void();
16165 return resultobj;
16166 fail:
16167 return NULL;
16168 }
16169
16170
16171 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16172 PyObject *resultobj = 0;
16173 wxGrid *arg1 = (wxGrid *) 0 ;
16174 bool arg2 = (bool) true ;
16175 void *argp1 = 0 ;
16176 int res1 = 0 ;
16177 bool val2 ;
16178 int ecode2 = 0 ;
16179 PyObject * obj0 = 0 ;
16180 PyObject * obj1 = 0 ;
16181 char * kwnames[] = {
16182 (char *) "self",(char *) "setAsMin", NULL
16183 };
16184
16185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
16186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16187 if (!SWIG_IsOK(res1)) {
16188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
16189 }
16190 arg1 = reinterpret_cast< wxGrid * >(argp1);
16191 if (obj1) {
16192 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16193 if (!SWIG_IsOK(ecode2)) {
16194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
16195 }
16196 arg2 = static_cast< bool >(val2);
16197 }
16198 {
16199 PyThreadState* __tstate = wxPyBeginAllowThreads();
16200 (arg1)->AutoSizeRows(arg2);
16201 wxPyEndAllowThreads(__tstate);
16202 if (PyErr_Occurred()) SWIG_fail;
16203 }
16204 resultobj = SWIG_Py_Void();
16205 return resultobj;
16206 fail:
16207 return NULL;
16208 }
16209
16210
16211 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16212 PyObject *resultobj = 0;
16213 wxGrid *arg1 = (wxGrid *) 0 ;
16214 void *argp1 = 0 ;
16215 int res1 = 0 ;
16216 PyObject *swig_obj[1] ;
16217
16218 if (!args) SWIG_fail;
16219 swig_obj[0] = args;
16220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16221 if (!SWIG_IsOK(res1)) {
16222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16223 }
16224 arg1 = reinterpret_cast< wxGrid * >(argp1);
16225 {
16226 PyThreadState* __tstate = wxPyBeginAllowThreads();
16227 (arg1)->AutoSize();
16228 wxPyEndAllowThreads(__tstate);
16229 if (PyErr_Occurred()) SWIG_fail;
16230 }
16231 resultobj = SWIG_Py_Void();
16232 return resultobj;
16233 fail:
16234 return NULL;
16235 }
16236
16237
16238 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16239 PyObject *resultobj = 0;
16240 wxGrid *arg1 = (wxGrid *) 0 ;
16241 int arg2 ;
16242 void *argp1 = 0 ;
16243 int res1 = 0 ;
16244 int val2 ;
16245 int ecode2 = 0 ;
16246 PyObject * obj0 = 0 ;
16247 PyObject * obj1 = 0 ;
16248 char * kwnames[] = {
16249 (char *) "self",(char *) "row", NULL
16250 };
16251
16252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16254 if (!SWIG_IsOK(res1)) {
16255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16256 }
16257 arg1 = reinterpret_cast< wxGrid * >(argp1);
16258 ecode2 = SWIG_AsVal_int(obj1, &val2);
16259 if (!SWIG_IsOK(ecode2)) {
16260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
16261 }
16262 arg2 = static_cast< int >(val2);
16263 {
16264 PyThreadState* __tstate = wxPyBeginAllowThreads();
16265 (arg1)->AutoSizeRowLabelSize(arg2);
16266 wxPyEndAllowThreads(__tstate);
16267 if (PyErr_Occurred()) SWIG_fail;
16268 }
16269 resultobj = SWIG_Py_Void();
16270 return resultobj;
16271 fail:
16272 return NULL;
16273 }
16274
16275
16276 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16277 PyObject *resultobj = 0;
16278 wxGrid *arg1 = (wxGrid *) 0 ;
16279 int arg2 ;
16280 void *argp1 = 0 ;
16281 int res1 = 0 ;
16282 int val2 ;
16283 int ecode2 = 0 ;
16284 PyObject * obj0 = 0 ;
16285 PyObject * obj1 = 0 ;
16286 char * kwnames[] = {
16287 (char *) "self",(char *) "col", NULL
16288 };
16289
16290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
16291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16292 if (!SWIG_IsOK(res1)) {
16293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16294 }
16295 arg1 = reinterpret_cast< wxGrid * >(argp1);
16296 ecode2 = SWIG_AsVal_int(obj1, &val2);
16297 if (!SWIG_IsOK(ecode2)) {
16298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
16299 }
16300 arg2 = static_cast< int >(val2);
16301 {
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 (arg1)->AutoSizeColLabelSize(arg2);
16304 wxPyEndAllowThreads(__tstate);
16305 if (PyErr_Occurred()) SWIG_fail;
16306 }
16307 resultobj = SWIG_Py_Void();
16308 return resultobj;
16309 fail:
16310 return NULL;
16311 }
16312
16313
16314 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16315 PyObject *resultobj = 0;
16316 wxGrid *arg1 = (wxGrid *) 0 ;
16317 int arg2 ;
16318 int arg3 ;
16319 void *argp1 = 0 ;
16320 int res1 = 0 ;
16321 int val2 ;
16322 int ecode2 = 0 ;
16323 int val3 ;
16324 int ecode3 = 0 ;
16325 PyObject * obj0 = 0 ;
16326 PyObject * obj1 = 0 ;
16327 PyObject * obj2 = 0 ;
16328 char * kwnames[] = {
16329 (char *) "self",(char *) "col",(char *) "width", NULL
16330 };
16331
16332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16334 if (!SWIG_IsOK(res1)) {
16335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16336 }
16337 arg1 = reinterpret_cast< wxGrid * >(argp1);
16338 ecode2 = SWIG_AsVal_int(obj1, &val2);
16339 if (!SWIG_IsOK(ecode2)) {
16340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
16341 }
16342 arg2 = static_cast< int >(val2);
16343 ecode3 = SWIG_AsVal_int(obj2, &val3);
16344 if (!SWIG_IsOK(ecode3)) {
16345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
16346 }
16347 arg3 = static_cast< int >(val3);
16348 {
16349 PyThreadState* __tstate = wxPyBeginAllowThreads();
16350 (arg1)->SetColMinimalWidth(arg2,arg3);
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 resultobj = SWIG_Py_Void();
16355 return resultobj;
16356 fail:
16357 return NULL;
16358 }
16359
16360
16361 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16362 PyObject *resultobj = 0;
16363 wxGrid *arg1 = (wxGrid *) 0 ;
16364 int arg2 ;
16365 int arg3 ;
16366 void *argp1 = 0 ;
16367 int res1 = 0 ;
16368 int val2 ;
16369 int ecode2 = 0 ;
16370 int val3 ;
16371 int ecode3 = 0 ;
16372 PyObject * obj0 = 0 ;
16373 PyObject * obj1 = 0 ;
16374 PyObject * obj2 = 0 ;
16375 char * kwnames[] = {
16376 (char *) "self",(char *) "row",(char *) "width", NULL
16377 };
16378
16379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16381 if (!SWIG_IsOK(res1)) {
16382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16383 }
16384 arg1 = reinterpret_cast< wxGrid * >(argp1);
16385 ecode2 = SWIG_AsVal_int(obj1, &val2);
16386 if (!SWIG_IsOK(ecode2)) {
16387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
16388 }
16389 arg2 = static_cast< int >(val2);
16390 ecode3 = SWIG_AsVal_int(obj2, &val3);
16391 if (!SWIG_IsOK(ecode3)) {
16392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
16393 }
16394 arg3 = static_cast< int >(val3);
16395 {
16396 PyThreadState* __tstate = wxPyBeginAllowThreads();
16397 (arg1)->SetRowMinimalHeight(arg2,arg3);
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 resultobj = SWIG_Py_Void();
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj = 0;
16410 wxGrid *arg1 = (wxGrid *) 0 ;
16411 int arg2 ;
16412 void *argp1 = 0 ;
16413 int res1 = 0 ;
16414 int val2 ;
16415 int ecode2 = 0 ;
16416 PyObject * obj0 = 0 ;
16417 PyObject * obj1 = 0 ;
16418 char * kwnames[] = {
16419 (char *) "self",(char *) "width", NULL
16420 };
16421
16422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
16423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
16426 }
16427 arg1 = reinterpret_cast< wxGrid * >(argp1);
16428 ecode2 = SWIG_AsVal_int(obj1, &val2);
16429 if (!SWIG_IsOK(ecode2)) {
16430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
16431 }
16432 arg2 = static_cast< int >(val2);
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 (arg1)->SetColMinimalAcceptableWidth(arg2);
16436 wxPyEndAllowThreads(__tstate);
16437 if (PyErr_Occurred()) SWIG_fail;
16438 }
16439 resultobj = SWIG_Py_Void();
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj = 0;
16448 wxGrid *arg1 = (wxGrid *) 0 ;
16449 int arg2 ;
16450 void *argp1 = 0 ;
16451 int res1 = 0 ;
16452 int val2 ;
16453 int ecode2 = 0 ;
16454 PyObject * obj0 = 0 ;
16455 PyObject * obj1 = 0 ;
16456 char * kwnames[] = {
16457 (char *) "self",(char *) "width", NULL
16458 };
16459
16460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
16461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16462 if (!SWIG_IsOK(res1)) {
16463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
16464 }
16465 arg1 = reinterpret_cast< wxGrid * >(argp1);
16466 ecode2 = SWIG_AsVal_int(obj1, &val2);
16467 if (!SWIG_IsOK(ecode2)) {
16468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
16469 }
16470 arg2 = static_cast< int >(val2);
16471 {
16472 PyThreadState* __tstate = wxPyBeginAllowThreads();
16473 (arg1)->SetRowMinimalAcceptableHeight(arg2);
16474 wxPyEndAllowThreads(__tstate);
16475 if (PyErr_Occurred()) SWIG_fail;
16476 }
16477 resultobj = SWIG_Py_Void();
16478 return resultobj;
16479 fail:
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16485 PyObject *resultobj = 0;
16486 wxGrid *arg1 = (wxGrid *) 0 ;
16487 int result;
16488 void *argp1 = 0 ;
16489 int res1 = 0 ;
16490 PyObject *swig_obj[1] ;
16491
16492 if (!args) SWIG_fail;
16493 swig_obj[0] = args;
16494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16495 if (!SWIG_IsOK(res1)) {
16496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
16497 }
16498 arg1 = reinterpret_cast< wxGrid * >(argp1);
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 resultobj = SWIG_From_int(static_cast< int >(result));
16506 return resultobj;
16507 fail:
16508 return NULL;
16509 }
16510
16511
16512 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16513 PyObject *resultobj = 0;
16514 wxGrid *arg1 = (wxGrid *) 0 ;
16515 int result;
16516 void *argp1 = 0 ;
16517 int res1 = 0 ;
16518 PyObject *swig_obj[1] ;
16519
16520 if (!args) SWIG_fail;
16521 swig_obj[0] = args;
16522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16523 if (!SWIG_IsOK(res1)) {
16524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
16525 }
16526 arg1 = reinterpret_cast< wxGrid * >(argp1);
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
16530 wxPyEndAllowThreads(__tstate);
16531 if (PyErr_Occurred()) SWIG_fail;
16532 }
16533 resultobj = SWIG_From_int(static_cast< int >(result));
16534 return resultobj;
16535 fail:
16536 return NULL;
16537 }
16538
16539
16540 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16541 PyObject *resultobj = 0;
16542 wxGrid *arg1 = (wxGrid *) 0 ;
16543 wxColour *arg2 = 0 ;
16544 void *argp1 = 0 ;
16545 int res1 = 0 ;
16546 wxColour temp2 ;
16547 PyObject * obj0 = 0 ;
16548 PyObject * obj1 = 0 ;
16549 char * kwnames[] = {
16550 (char *) "self",(char *)"arg2", NULL
16551 };
16552
16553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
16554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16555 if (!SWIG_IsOK(res1)) {
16556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16557 }
16558 arg1 = reinterpret_cast< wxGrid * >(argp1);
16559 {
16560 arg2 = &temp2;
16561 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16562 }
16563 {
16564 PyThreadState* __tstate = wxPyBeginAllowThreads();
16565 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
16566 wxPyEndAllowThreads(__tstate);
16567 if (PyErr_Occurred()) SWIG_fail;
16568 }
16569 resultobj = SWIG_Py_Void();
16570 return resultobj;
16571 fail:
16572 return NULL;
16573 }
16574
16575
16576 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16577 PyObject *resultobj = 0;
16578 wxGrid *arg1 = (wxGrid *) 0 ;
16579 int arg2 ;
16580 int arg3 ;
16581 wxColour *arg4 = 0 ;
16582 void *argp1 = 0 ;
16583 int res1 = 0 ;
16584 int val2 ;
16585 int ecode2 = 0 ;
16586 int val3 ;
16587 int ecode3 = 0 ;
16588 wxColour temp4 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 PyObject * obj2 = 0 ;
16592 PyObject * obj3 = 0 ;
16593 char * kwnames[] = {
16594 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16595 };
16596
16597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16599 if (!SWIG_IsOK(res1)) {
16600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16601 }
16602 arg1 = reinterpret_cast< wxGrid * >(argp1);
16603 ecode2 = SWIG_AsVal_int(obj1, &val2);
16604 if (!SWIG_IsOK(ecode2)) {
16605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
16606 }
16607 arg2 = static_cast< int >(val2);
16608 ecode3 = SWIG_AsVal_int(obj2, &val3);
16609 if (!SWIG_IsOK(ecode3)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
16611 }
16612 arg3 = static_cast< int >(val3);
16613 {
16614 arg4 = &temp4;
16615 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16616 }
16617 {
16618 PyThreadState* __tstate = wxPyBeginAllowThreads();
16619 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16620 wxPyEndAllowThreads(__tstate);
16621 if (PyErr_Occurred()) SWIG_fail;
16622 }
16623 resultobj = SWIG_Py_Void();
16624 return resultobj;
16625 fail:
16626 return NULL;
16627 }
16628
16629
16630 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16631 PyObject *resultobj = 0;
16632 wxGrid *arg1 = (wxGrid *) 0 ;
16633 wxColour *arg2 = 0 ;
16634 void *argp1 = 0 ;
16635 int res1 = 0 ;
16636 wxColour temp2 ;
16637 PyObject * obj0 = 0 ;
16638 PyObject * obj1 = 0 ;
16639 char * kwnames[] = {
16640 (char *) "self",(char *)"arg2", NULL
16641 };
16642
16643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16645 if (!SWIG_IsOK(res1)) {
16646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16647 }
16648 arg1 = reinterpret_cast< wxGrid * >(argp1);
16649 {
16650 arg2 = &temp2;
16651 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16652 }
16653 {
16654 PyThreadState* __tstate = wxPyBeginAllowThreads();
16655 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 resultobj = SWIG_Py_Void();
16660 return resultobj;
16661 fail:
16662 return NULL;
16663 }
16664
16665
16666 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16667 PyObject *resultobj = 0;
16668 wxGrid *arg1 = (wxGrid *) 0 ;
16669 int arg2 ;
16670 int arg3 ;
16671 wxColour *arg4 = 0 ;
16672 void *argp1 = 0 ;
16673 int res1 = 0 ;
16674 int val2 ;
16675 int ecode2 = 0 ;
16676 int val3 ;
16677 int ecode3 = 0 ;
16678 wxColour temp4 ;
16679 PyObject * obj0 = 0 ;
16680 PyObject * obj1 = 0 ;
16681 PyObject * obj2 = 0 ;
16682 PyObject * obj3 = 0 ;
16683 char * kwnames[] = {
16684 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16685 };
16686
16687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16689 if (!SWIG_IsOK(res1)) {
16690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16691 }
16692 arg1 = reinterpret_cast< wxGrid * >(argp1);
16693 ecode2 = SWIG_AsVal_int(obj1, &val2);
16694 if (!SWIG_IsOK(ecode2)) {
16695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16696 }
16697 arg2 = static_cast< int >(val2);
16698 ecode3 = SWIG_AsVal_int(obj2, &val3);
16699 if (!SWIG_IsOK(ecode3)) {
16700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16701 }
16702 arg3 = static_cast< int >(val3);
16703 {
16704 arg4 = &temp4;
16705 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16706 }
16707 {
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 resultobj = SWIG_Py_Void();
16714 return resultobj;
16715 fail:
16716 return NULL;
16717 }
16718
16719
16720 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16721 PyObject *resultobj = 0;
16722 wxGrid *arg1 = (wxGrid *) 0 ;
16723 wxFont *arg2 = 0 ;
16724 void *argp1 = 0 ;
16725 int res1 = 0 ;
16726 void *argp2 = 0 ;
16727 int res2 = 0 ;
16728 PyObject * obj0 = 0 ;
16729 PyObject * obj1 = 0 ;
16730 char * kwnames[] = {
16731 (char *) "self",(char *)"arg2", NULL
16732 };
16733
16734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16736 if (!SWIG_IsOK(res1)) {
16737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16738 }
16739 arg1 = reinterpret_cast< wxGrid * >(argp1);
16740 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16741 if (!SWIG_IsOK(res2)) {
16742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16743 }
16744 if (!argp2) {
16745 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16746 }
16747 arg2 = reinterpret_cast< wxFont * >(argp2);
16748 {
16749 PyThreadState* __tstate = wxPyBeginAllowThreads();
16750 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16751 wxPyEndAllowThreads(__tstate);
16752 if (PyErr_Occurred()) SWIG_fail;
16753 }
16754 resultobj = SWIG_Py_Void();
16755 return resultobj;
16756 fail:
16757 return NULL;
16758 }
16759
16760
16761 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16762 PyObject *resultobj = 0;
16763 wxGrid *arg1 = (wxGrid *) 0 ;
16764 int arg2 ;
16765 int arg3 ;
16766 wxFont *arg4 = 0 ;
16767 void *argp1 = 0 ;
16768 int res1 = 0 ;
16769 int val2 ;
16770 int ecode2 = 0 ;
16771 int val3 ;
16772 int ecode3 = 0 ;
16773 void *argp4 = 0 ;
16774 int res4 = 0 ;
16775 PyObject * obj0 = 0 ;
16776 PyObject * obj1 = 0 ;
16777 PyObject * obj2 = 0 ;
16778 PyObject * obj3 = 0 ;
16779 char * kwnames[] = {
16780 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16781 };
16782
16783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16785 if (!SWIG_IsOK(res1)) {
16786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16787 }
16788 arg1 = reinterpret_cast< wxGrid * >(argp1);
16789 ecode2 = SWIG_AsVal_int(obj1, &val2);
16790 if (!SWIG_IsOK(ecode2)) {
16791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16792 }
16793 arg2 = static_cast< int >(val2);
16794 ecode3 = SWIG_AsVal_int(obj2, &val3);
16795 if (!SWIG_IsOK(ecode3)) {
16796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16797 }
16798 arg3 = static_cast< int >(val3);
16799 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16800 if (!SWIG_IsOK(res4)) {
16801 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16802 }
16803 if (!argp4) {
16804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16805 }
16806 arg4 = reinterpret_cast< wxFont * >(argp4);
16807 {
16808 PyThreadState* __tstate = wxPyBeginAllowThreads();
16809 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16810 wxPyEndAllowThreads(__tstate);
16811 if (PyErr_Occurred()) SWIG_fail;
16812 }
16813 resultobj = SWIG_Py_Void();
16814 return resultobj;
16815 fail:
16816 return NULL;
16817 }
16818
16819
16820 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16821 PyObject *resultobj = 0;
16822 wxGrid *arg1 = (wxGrid *) 0 ;
16823 int arg2 ;
16824 int arg3 ;
16825 void *argp1 = 0 ;
16826 int res1 = 0 ;
16827 int val2 ;
16828 int ecode2 = 0 ;
16829 int val3 ;
16830 int ecode3 = 0 ;
16831 PyObject * obj0 = 0 ;
16832 PyObject * obj1 = 0 ;
16833 PyObject * obj2 = 0 ;
16834 char * kwnames[] = {
16835 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16836 };
16837
16838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16840 if (!SWIG_IsOK(res1)) {
16841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16842 }
16843 arg1 = reinterpret_cast< wxGrid * >(argp1);
16844 ecode2 = SWIG_AsVal_int(obj1, &val2);
16845 if (!SWIG_IsOK(ecode2)) {
16846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16847 }
16848 arg2 = static_cast< int >(val2);
16849 ecode3 = SWIG_AsVal_int(obj2, &val3);
16850 if (!SWIG_IsOK(ecode3)) {
16851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16852 }
16853 arg3 = static_cast< int >(val3);
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 resultobj = SWIG_Py_Void();
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj = 0;
16869 wxGrid *arg1 = (wxGrid *) 0 ;
16870 int arg2 ;
16871 int arg3 ;
16872 int arg4 ;
16873 int arg5 ;
16874 void *argp1 = 0 ;
16875 int res1 = 0 ;
16876 int val2 ;
16877 int ecode2 = 0 ;
16878 int val3 ;
16879 int ecode3 = 0 ;
16880 int val4 ;
16881 int ecode4 = 0 ;
16882 int val5 ;
16883 int ecode5 = 0 ;
16884 PyObject * obj0 = 0 ;
16885 PyObject * obj1 = 0 ;
16886 PyObject * obj2 = 0 ;
16887 PyObject * obj3 = 0 ;
16888 PyObject * obj4 = 0 ;
16889 char * kwnames[] = {
16890 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16891 };
16892
16893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16895 if (!SWIG_IsOK(res1)) {
16896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16897 }
16898 arg1 = reinterpret_cast< wxGrid * >(argp1);
16899 ecode2 = SWIG_AsVal_int(obj1, &val2);
16900 if (!SWIG_IsOK(ecode2)) {
16901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16902 }
16903 arg2 = static_cast< int >(val2);
16904 ecode3 = SWIG_AsVal_int(obj2, &val3);
16905 if (!SWIG_IsOK(ecode3)) {
16906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16907 }
16908 arg3 = static_cast< int >(val3);
16909 ecode4 = SWIG_AsVal_int(obj3, &val4);
16910 if (!SWIG_IsOK(ecode4)) {
16911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16912 }
16913 arg4 = static_cast< int >(val4);
16914 ecode5 = SWIG_AsVal_int(obj4, &val5);
16915 if (!SWIG_IsOK(ecode5)) {
16916 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16917 }
16918 arg5 = static_cast< int >(val5);
16919 {
16920 PyThreadState* __tstate = wxPyBeginAllowThreads();
16921 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 resultobj = SWIG_Py_Void();
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj = 0;
16934 wxGrid *arg1 = (wxGrid *) 0 ;
16935 bool arg2 ;
16936 void *argp1 = 0 ;
16937 int res1 = 0 ;
16938 bool val2 ;
16939 int ecode2 = 0 ;
16940 PyObject * obj0 = 0 ;
16941 PyObject * obj1 = 0 ;
16942 char * kwnames[] = {
16943 (char *) "self",(char *) "allow", NULL
16944 };
16945
16946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16948 if (!SWIG_IsOK(res1)) {
16949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16950 }
16951 arg1 = reinterpret_cast< wxGrid * >(argp1);
16952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16953 if (!SWIG_IsOK(ecode2)) {
16954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16955 }
16956 arg2 = static_cast< bool >(val2);
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 (arg1)->SetDefaultCellOverflow(arg2);
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 resultobj = SWIG_Py_Void();
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16971 PyObject *resultobj = 0;
16972 wxGrid *arg1 = (wxGrid *) 0 ;
16973 int arg2 ;
16974 int arg3 ;
16975 bool arg4 ;
16976 void *argp1 = 0 ;
16977 int res1 = 0 ;
16978 int val2 ;
16979 int ecode2 = 0 ;
16980 int val3 ;
16981 int ecode3 = 0 ;
16982 bool val4 ;
16983 int ecode4 = 0 ;
16984 PyObject * obj0 = 0 ;
16985 PyObject * obj1 = 0 ;
16986 PyObject * obj2 = 0 ;
16987 PyObject * obj3 = 0 ;
16988 char * kwnames[] = {
16989 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16990 };
16991
16992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16994 if (!SWIG_IsOK(res1)) {
16995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16996 }
16997 arg1 = reinterpret_cast< wxGrid * >(argp1);
16998 ecode2 = SWIG_AsVal_int(obj1, &val2);
16999 if (!SWIG_IsOK(ecode2)) {
17000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
17001 }
17002 arg2 = static_cast< int >(val2);
17003 ecode3 = SWIG_AsVal_int(obj2, &val3);
17004 if (!SWIG_IsOK(ecode3)) {
17005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
17006 }
17007 arg3 = static_cast< int >(val3);
17008 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17009 if (!SWIG_IsOK(ecode4)) {
17010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
17011 }
17012 arg4 = static_cast< bool >(val4);
17013 {
17014 PyThreadState* __tstate = wxPyBeginAllowThreads();
17015 (arg1)->SetCellOverflow(arg2,arg3,arg4);
17016 wxPyEndAllowThreads(__tstate);
17017 if (PyErr_Occurred()) SWIG_fail;
17018 }
17019 resultobj = SWIG_Py_Void();
17020 return resultobj;
17021 fail:
17022 return NULL;
17023 }
17024
17025
17026 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17027 PyObject *resultobj = 0;
17028 wxGrid *arg1 = (wxGrid *) 0 ;
17029 int arg2 ;
17030 int arg3 ;
17031 int arg4 ;
17032 int arg5 ;
17033 void *argp1 = 0 ;
17034 int res1 = 0 ;
17035 int val2 ;
17036 int ecode2 = 0 ;
17037 int val3 ;
17038 int ecode3 = 0 ;
17039 int val4 ;
17040 int ecode4 = 0 ;
17041 int val5 ;
17042 int ecode5 = 0 ;
17043 PyObject * obj0 = 0 ;
17044 PyObject * obj1 = 0 ;
17045 PyObject * obj2 = 0 ;
17046 PyObject * obj3 = 0 ;
17047 PyObject * obj4 = 0 ;
17048 char * kwnames[] = {
17049 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
17050 };
17051
17052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17054 if (!SWIG_IsOK(res1)) {
17055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
17056 }
17057 arg1 = reinterpret_cast< wxGrid * >(argp1);
17058 ecode2 = SWIG_AsVal_int(obj1, &val2);
17059 if (!SWIG_IsOK(ecode2)) {
17060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
17061 }
17062 arg2 = static_cast< int >(val2);
17063 ecode3 = SWIG_AsVal_int(obj2, &val3);
17064 if (!SWIG_IsOK(ecode3)) {
17065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
17066 }
17067 arg3 = static_cast< int >(val3);
17068 ecode4 = SWIG_AsVal_int(obj3, &val4);
17069 if (!SWIG_IsOK(ecode4)) {
17070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
17071 }
17072 arg4 = static_cast< int >(val4);
17073 ecode5 = SWIG_AsVal_int(obj4, &val5);
17074 if (!SWIG_IsOK(ecode5)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
17076 }
17077 arg5 = static_cast< int >(val5);
17078 {
17079 PyThreadState* __tstate = wxPyBeginAllowThreads();
17080 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
17081 wxPyEndAllowThreads(__tstate);
17082 if (PyErr_Occurred()) SWIG_fail;
17083 }
17084 resultobj = SWIG_Py_Void();
17085 return resultobj;
17086 fail:
17087 return NULL;
17088 }
17089
17090
17091 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17092 PyObject *resultobj = 0;
17093 wxGrid *arg1 = (wxGrid *) 0 ;
17094 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
17095 void *argp1 = 0 ;
17096 int res1 = 0 ;
17097 void *argp2 = 0 ;
17098 int res2 = 0 ;
17099 PyObject * obj0 = 0 ;
17100 PyObject * obj1 = 0 ;
17101 char * kwnames[] = {
17102 (char *) "self",(char *) "renderer", NULL
17103 };
17104
17105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
17106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17107 if (!SWIG_IsOK(res1)) {
17108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17109 }
17110 arg1 = reinterpret_cast< wxGrid * >(argp1);
17111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17112 if (!SWIG_IsOK(res2)) {
17113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
17114 }
17115 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 (arg1)->SetDefaultRenderer(arg2);
17119 wxPyEndAllowThreads(__tstate);
17120 if (PyErr_Occurred()) SWIG_fail;
17121 }
17122 resultobj = SWIG_Py_Void();
17123 return resultobj;
17124 fail:
17125 return NULL;
17126 }
17127
17128
17129 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj = 0;
17131 wxGrid *arg1 = (wxGrid *) 0 ;
17132 int arg2 ;
17133 int arg3 ;
17134 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
17135 void *argp1 = 0 ;
17136 int res1 = 0 ;
17137 int val2 ;
17138 int ecode2 = 0 ;
17139 int val3 ;
17140 int ecode3 = 0 ;
17141 void *argp4 = 0 ;
17142 int res4 = 0 ;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 PyObject * obj2 = 0 ;
17146 PyObject * obj3 = 0 ;
17147 char * kwnames[] = {
17148 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
17149 };
17150
17151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17153 if (!SWIG_IsOK(res1)) {
17154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17155 }
17156 arg1 = reinterpret_cast< wxGrid * >(argp1);
17157 ecode2 = SWIG_AsVal_int(obj1, &val2);
17158 if (!SWIG_IsOK(ecode2)) {
17159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17160 }
17161 arg2 = static_cast< int >(val2);
17162 ecode3 = SWIG_AsVal_int(obj2, &val3);
17163 if (!SWIG_IsOK(ecode3)) {
17164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17165 }
17166 arg3 = static_cast< int >(val3);
17167 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17168 if (!SWIG_IsOK(res4)) {
17169 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
17170 }
17171 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
17172 {
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 (arg1)->SetCellRenderer(arg2,arg3,arg4);
17175 wxPyEndAllowThreads(__tstate);
17176 if (PyErr_Occurred()) SWIG_fail;
17177 }
17178 resultobj = SWIG_Py_Void();
17179 return resultobj;
17180 fail:
17181 return NULL;
17182 }
17183
17184
17185 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17186 PyObject *resultobj = 0;
17187 wxGrid *arg1 = (wxGrid *) 0 ;
17188 wxGridCellRenderer *result = 0 ;
17189 void *argp1 = 0 ;
17190 int res1 = 0 ;
17191 PyObject *swig_obj[1] ;
17192
17193 if (!args) SWIG_fail;
17194 swig_obj[0] = args;
17195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17196 if (!SWIG_IsOK(res1)) {
17197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
17198 }
17199 arg1 = reinterpret_cast< wxGrid * >(argp1);
17200 {
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 {
17207 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17208 }
17209 return resultobj;
17210 fail:
17211 return NULL;
17212 }
17213
17214
17215 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17216 PyObject *resultobj = 0;
17217 wxGrid *arg1 = (wxGrid *) 0 ;
17218 int arg2 ;
17219 int arg3 ;
17220 wxGridCellRenderer *result = 0 ;
17221 void *argp1 = 0 ;
17222 int res1 = 0 ;
17223 int val2 ;
17224 int ecode2 = 0 ;
17225 int val3 ;
17226 int ecode3 = 0 ;
17227 PyObject * obj0 = 0 ;
17228 PyObject * obj1 = 0 ;
17229 PyObject * obj2 = 0 ;
17230 char * kwnames[] = {
17231 (char *) "self",(char *) "row",(char *) "col", NULL
17232 };
17233
17234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17236 if (!SWIG_IsOK(res1)) {
17237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
17238 }
17239 arg1 = reinterpret_cast< wxGrid * >(argp1);
17240 ecode2 = SWIG_AsVal_int(obj1, &val2);
17241 if (!SWIG_IsOK(ecode2)) {
17242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
17243 }
17244 arg2 = static_cast< int >(val2);
17245 ecode3 = SWIG_AsVal_int(obj2, &val3);
17246 if (!SWIG_IsOK(ecode3)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
17248 }
17249 arg3 = static_cast< int >(val3);
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 {
17257 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17258 }
17259 return resultobj;
17260 fail:
17261 return NULL;
17262 }
17263
17264
17265 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17266 PyObject *resultobj = 0;
17267 wxGrid *arg1 = (wxGrid *) 0 ;
17268 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
17269 void *argp1 = 0 ;
17270 int res1 = 0 ;
17271 void *argp2 = 0 ;
17272 int res2 = 0 ;
17273 PyObject * obj0 = 0 ;
17274 PyObject * obj1 = 0 ;
17275 char * kwnames[] = {
17276 (char *) "self",(char *) "editor", NULL
17277 };
17278
17279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
17280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17281 if (!SWIG_IsOK(res1)) {
17282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17283 }
17284 arg1 = reinterpret_cast< wxGrid * >(argp1);
17285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17286 if (!SWIG_IsOK(res2)) {
17287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
17288 }
17289 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
17290 {
17291 PyThreadState* __tstate = wxPyBeginAllowThreads();
17292 (arg1)->SetDefaultEditor(arg2);
17293 wxPyEndAllowThreads(__tstate);
17294 if (PyErr_Occurred()) SWIG_fail;
17295 }
17296 resultobj = SWIG_Py_Void();
17297 return resultobj;
17298 fail:
17299 return NULL;
17300 }
17301
17302
17303 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17304 PyObject *resultobj = 0;
17305 wxGrid *arg1 = (wxGrid *) 0 ;
17306 int arg2 ;
17307 int arg3 ;
17308 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17309 void *argp1 = 0 ;
17310 int res1 = 0 ;
17311 int val2 ;
17312 int ecode2 = 0 ;
17313 int val3 ;
17314 int ecode3 = 0 ;
17315 void *argp4 = 0 ;
17316 int res4 = 0 ;
17317 PyObject * obj0 = 0 ;
17318 PyObject * obj1 = 0 ;
17319 PyObject * obj2 = 0 ;
17320 PyObject * obj3 = 0 ;
17321 char * kwnames[] = {
17322 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
17323 };
17324
17325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17327 if (!SWIG_IsOK(res1)) {
17328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17329 }
17330 arg1 = reinterpret_cast< wxGrid * >(argp1);
17331 ecode2 = SWIG_AsVal_int(obj1, &val2);
17332 if (!SWIG_IsOK(ecode2)) {
17333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
17334 }
17335 arg2 = static_cast< int >(val2);
17336 ecode3 = SWIG_AsVal_int(obj2, &val3);
17337 if (!SWIG_IsOK(ecode3)) {
17338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
17339 }
17340 arg3 = static_cast< int >(val3);
17341 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17342 if (!SWIG_IsOK(res4)) {
17343 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17344 }
17345 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17346 {
17347 PyThreadState* __tstate = wxPyBeginAllowThreads();
17348 (arg1)->SetCellEditor(arg2,arg3,arg4);
17349 wxPyEndAllowThreads(__tstate);
17350 if (PyErr_Occurred()) SWIG_fail;
17351 }
17352 resultobj = SWIG_Py_Void();
17353 return resultobj;
17354 fail:
17355 return NULL;
17356 }
17357
17358
17359 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17360 PyObject *resultobj = 0;
17361 wxGrid *arg1 = (wxGrid *) 0 ;
17362 wxGridCellEditor *result = 0 ;
17363 void *argp1 = 0 ;
17364 int res1 = 0 ;
17365 PyObject *swig_obj[1] ;
17366
17367 if (!args) SWIG_fail;
17368 swig_obj[0] = args;
17369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17370 if (!SWIG_IsOK(res1)) {
17371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
17372 }
17373 arg1 = reinterpret_cast< wxGrid * >(argp1);
17374 {
17375 PyThreadState* __tstate = wxPyBeginAllowThreads();
17376 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
17377 wxPyEndAllowThreads(__tstate);
17378 if (PyErr_Occurred()) SWIG_fail;
17379 }
17380 {
17381 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17382 }
17383 return resultobj;
17384 fail:
17385 return NULL;
17386 }
17387
17388
17389 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17390 PyObject *resultobj = 0;
17391 wxGrid *arg1 = (wxGrid *) 0 ;
17392 int arg2 ;
17393 int arg3 ;
17394 wxGridCellEditor *result = 0 ;
17395 void *argp1 = 0 ;
17396 int res1 = 0 ;
17397 int val2 ;
17398 int ecode2 = 0 ;
17399 int val3 ;
17400 int ecode3 = 0 ;
17401 PyObject * obj0 = 0 ;
17402 PyObject * obj1 = 0 ;
17403 PyObject * obj2 = 0 ;
17404 char * kwnames[] = {
17405 (char *) "self",(char *) "row",(char *) "col", NULL
17406 };
17407
17408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17410 if (!SWIG_IsOK(res1)) {
17411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
17412 }
17413 arg1 = reinterpret_cast< wxGrid * >(argp1);
17414 ecode2 = SWIG_AsVal_int(obj1, &val2);
17415 if (!SWIG_IsOK(ecode2)) {
17416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
17417 }
17418 arg2 = static_cast< int >(val2);
17419 ecode3 = SWIG_AsVal_int(obj2, &val3);
17420 if (!SWIG_IsOK(ecode3)) {
17421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
17422 }
17423 arg3 = static_cast< int >(val3);
17424 {
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
17427 wxPyEndAllowThreads(__tstate);
17428 if (PyErr_Occurred()) SWIG_fail;
17429 }
17430 {
17431 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17432 }
17433 return resultobj;
17434 fail:
17435 return NULL;
17436 }
17437
17438
17439 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17440 PyObject *resultobj = 0;
17441 wxGrid *arg1 = (wxGrid *) 0 ;
17442 int arg2 ;
17443 int arg3 ;
17444 wxString result;
17445 void *argp1 = 0 ;
17446 int res1 = 0 ;
17447 int val2 ;
17448 int ecode2 = 0 ;
17449 int val3 ;
17450 int ecode3 = 0 ;
17451 PyObject * obj0 = 0 ;
17452 PyObject * obj1 = 0 ;
17453 PyObject * obj2 = 0 ;
17454 char * kwnames[] = {
17455 (char *) "self",(char *) "row",(char *) "col", NULL
17456 };
17457
17458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17460 if (!SWIG_IsOK(res1)) {
17461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17462 }
17463 arg1 = reinterpret_cast< wxGrid * >(argp1);
17464 ecode2 = SWIG_AsVal_int(obj1, &val2);
17465 if (!SWIG_IsOK(ecode2)) {
17466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
17467 }
17468 arg2 = static_cast< int >(val2);
17469 ecode3 = SWIG_AsVal_int(obj2, &val3);
17470 if (!SWIG_IsOK(ecode3)) {
17471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
17472 }
17473 arg3 = static_cast< int >(val3);
17474 {
17475 PyThreadState* __tstate = wxPyBeginAllowThreads();
17476 result = (arg1)->GetCellValue(arg2,arg3);
17477 wxPyEndAllowThreads(__tstate);
17478 if (PyErr_Occurred()) SWIG_fail;
17479 }
17480 {
17481 #if wxUSE_UNICODE
17482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17483 #else
17484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17485 #endif
17486 }
17487 return resultobj;
17488 fail:
17489 return NULL;
17490 }
17491
17492
17493 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17494 PyObject *resultobj = 0;
17495 wxGrid *arg1 = (wxGrid *) 0 ;
17496 int arg2 ;
17497 int arg3 ;
17498 wxString *arg4 = 0 ;
17499 void *argp1 = 0 ;
17500 int res1 = 0 ;
17501 int val2 ;
17502 int ecode2 = 0 ;
17503 int val3 ;
17504 int ecode3 = 0 ;
17505 bool temp4 = false ;
17506 PyObject * obj0 = 0 ;
17507 PyObject * obj1 = 0 ;
17508 PyObject * obj2 = 0 ;
17509 PyObject * obj3 = 0 ;
17510 char * kwnames[] = {
17511 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
17512 };
17513
17514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17516 if (!SWIG_IsOK(res1)) {
17517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
17518 }
17519 arg1 = reinterpret_cast< wxGrid * >(argp1);
17520 ecode2 = SWIG_AsVal_int(obj1, &val2);
17521 if (!SWIG_IsOK(ecode2)) {
17522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
17523 }
17524 arg2 = static_cast< int >(val2);
17525 ecode3 = SWIG_AsVal_int(obj2, &val3);
17526 if (!SWIG_IsOK(ecode3)) {
17527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
17528 }
17529 arg3 = static_cast< int >(val3);
17530 {
17531 arg4 = wxString_in_helper(obj3);
17532 if (arg4 == NULL) SWIG_fail;
17533 temp4 = true;
17534 }
17535 {
17536 PyThreadState* __tstate = wxPyBeginAllowThreads();
17537 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
17538 wxPyEndAllowThreads(__tstate);
17539 if (PyErr_Occurred()) SWIG_fail;
17540 }
17541 resultobj = SWIG_Py_Void();
17542 {
17543 if (temp4)
17544 delete arg4;
17545 }
17546 return resultobj;
17547 fail:
17548 {
17549 if (temp4)
17550 delete arg4;
17551 }
17552 return NULL;
17553 }
17554
17555
17556 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj = 0;
17558 wxGrid *arg1 = (wxGrid *) 0 ;
17559 int arg2 ;
17560 int arg3 ;
17561 bool result;
17562 void *argp1 = 0 ;
17563 int res1 = 0 ;
17564 int val2 ;
17565 int ecode2 = 0 ;
17566 int val3 ;
17567 int ecode3 = 0 ;
17568 PyObject * obj0 = 0 ;
17569 PyObject * obj1 = 0 ;
17570 PyObject * obj2 = 0 ;
17571 char * kwnames[] = {
17572 (char *) "self",(char *) "row",(char *) "col", NULL
17573 };
17574
17575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17577 if (!SWIG_IsOK(res1)) {
17578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
17579 }
17580 arg1 = reinterpret_cast< wxGrid * >(argp1);
17581 ecode2 = SWIG_AsVal_int(obj1, &val2);
17582 if (!SWIG_IsOK(ecode2)) {
17583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
17584 }
17585 arg2 = static_cast< int >(val2);
17586 ecode3 = SWIG_AsVal_int(obj2, &val3);
17587 if (!SWIG_IsOK(ecode3)) {
17588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
17589 }
17590 arg3 = static_cast< int >(val3);
17591 {
17592 PyThreadState* __tstate = wxPyBeginAllowThreads();
17593 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 {
17598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17599 }
17600 return resultobj;
17601 fail:
17602 return NULL;
17603 }
17604
17605
17606 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17607 PyObject *resultobj = 0;
17608 wxGrid *arg1 = (wxGrid *) 0 ;
17609 int arg2 ;
17610 int arg3 ;
17611 bool arg4 = (bool) true ;
17612 void *argp1 = 0 ;
17613 int res1 = 0 ;
17614 int val2 ;
17615 int ecode2 = 0 ;
17616 int val3 ;
17617 int ecode3 = 0 ;
17618 bool val4 ;
17619 int ecode4 = 0 ;
17620 PyObject * obj0 = 0 ;
17621 PyObject * obj1 = 0 ;
17622 PyObject * obj2 = 0 ;
17623 PyObject * obj3 = 0 ;
17624 char * kwnames[] = {
17625 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17626 };
17627
17628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17630 if (!SWIG_IsOK(res1)) {
17631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17632 }
17633 arg1 = reinterpret_cast< wxGrid * >(argp1);
17634 ecode2 = SWIG_AsVal_int(obj1, &val2);
17635 if (!SWIG_IsOK(ecode2)) {
17636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17637 }
17638 arg2 = static_cast< int >(val2);
17639 ecode3 = SWIG_AsVal_int(obj2, &val3);
17640 if (!SWIG_IsOK(ecode3)) {
17641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17642 }
17643 arg3 = static_cast< int >(val3);
17644 if (obj3) {
17645 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17646 if (!SWIG_IsOK(ecode4)) {
17647 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17648 }
17649 arg4 = static_cast< bool >(val4);
17650 }
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 (arg1)->SetReadOnly(arg2,arg3,arg4);
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 resultobj = SWIG_Py_Void();
17658 return resultobj;
17659 fail:
17660 return NULL;
17661 }
17662
17663
17664 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17665 PyObject *resultobj = 0;
17666 wxGrid *arg1 = (wxGrid *) 0 ;
17667 int arg2 ;
17668 bool arg3 = (bool) false ;
17669 void *argp1 = 0 ;
17670 int res1 = 0 ;
17671 int val2 ;
17672 int ecode2 = 0 ;
17673 bool val3 ;
17674 int ecode3 = 0 ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 PyObject * obj2 = 0 ;
17678 char * kwnames[] = {
17679 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17680 };
17681
17682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17684 if (!SWIG_IsOK(res1)) {
17685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17686 }
17687 arg1 = reinterpret_cast< wxGrid * >(argp1);
17688 ecode2 = SWIG_AsVal_int(obj1, &val2);
17689 if (!SWIG_IsOK(ecode2)) {
17690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17691 }
17692 arg2 = static_cast< int >(val2);
17693 if (obj2) {
17694 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17695 if (!SWIG_IsOK(ecode3)) {
17696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17697 }
17698 arg3 = static_cast< bool >(val3);
17699 }
17700 {
17701 PyThreadState* __tstate = wxPyBeginAllowThreads();
17702 (arg1)->SelectRow(arg2,arg3);
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 resultobj = SWIG_Py_Void();
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17714 PyObject *resultobj = 0;
17715 wxGrid *arg1 = (wxGrid *) 0 ;
17716 int arg2 ;
17717 bool arg3 = (bool) false ;
17718 void *argp1 = 0 ;
17719 int res1 = 0 ;
17720 int val2 ;
17721 int ecode2 = 0 ;
17722 bool val3 ;
17723 int ecode3 = 0 ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 PyObject * obj2 = 0 ;
17727 char * kwnames[] = {
17728 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17729 };
17730
17731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17733 if (!SWIG_IsOK(res1)) {
17734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17735 }
17736 arg1 = reinterpret_cast< wxGrid * >(argp1);
17737 ecode2 = SWIG_AsVal_int(obj1, &val2);
17738 if (!SWIG_IsOK(ecode2)) {
17739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17740 }
17741 arg2 = static_cast< int >(val2);
17742 if (obj2) {
17743 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17744 if (!SWIG_IsOK(ecode3)) {
17745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17746 }
17747 arg3 = static_cast< bool >(val3);
17748 }
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 (arg1)->SelectCol(arg2,arg3);
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 resultobj = SWIG_Py_Void();
17756 return resultobj;
17757 fail:
17758 return NULL;
17759 }
17760
17761
17762 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17763 PyObject *resultobj = 0;
17764 wxGrid *arg1 = (wxGrid *) 0 ;
17765 int arg2 ;
17766 int arg3 ;
17767 int arg4 ;
17768 int arg5 ;
17769 bool arg6 = (bool) false ;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 int val2 ;
17773 int ecode2 = 0 ;
17774 int val3 ;
17775 int ecode3 = 0 ;
17776 int val4 ;
17777 int ecode4 = 0 ;
17778 int val5 ;
17779 int ecode5 = 0 ;
17780 bool val6 ;
17781 int ecode6 = 0 ;
17782 PyObject * obj0 = 0 ;
17783 PyObject * obj1 = 0 ;
17784 PyObject * obj2 = 0 ;
17785 PyObject * obj3 = 0 ;
17786 PyObject * obj4 = 0 ;
17787 PyObject * obj5 = 0 ;
17788 char * kwnames[] = {
17789 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17790 };
17791
17792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17794 if (!SWIG_IsOK(res1)) {
17795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17796 }
17797 arg1 = reinterpret_cast< wxGrid * >(argp1);
17798 ecode2 = SWIG_AsVal_int(obj1, &val2);
17799 if (!SWIG_IsOK(ecode2)) {
17800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17801 }
17802 arg2 = static_cast< int >(val2);
17803 ecode3 = SWIG_AsVal_int(obj2, &val3);
17804 if (!SWIG_IsOK(ecode3)) {
17805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17806 }
17807 arg3 = static_cast< int >(val3);
17808 ecode4 = SWIG_AsVal_int(obj3, &val4);
17809 if (!SWIG_IsOK(ecode4)) {
17810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17811 }
17812 arg4 = static_cast< int >(val4);
17813 ecode5 = SWIG_AsVal_int(obj4, &val5);
17814 if (!SWIG_IsOK(ecode5)) {
17815 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17816 }
17817 arg5 = static_cast< int >(val5);
17818 if (obj5) {
17819 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17820 if (!SWIG_IsOK(ecode6)) {
17821 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17822 }
17823 arg6 = static_cast< bool >(val6);
17824 }
17825 {
17826 PyThreadState* __tstate = wxPyBeginAllowThreads();
17827 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 resultobj = SWIG_Py_Void();
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839 PyObject *resultobj = 0;
17840 wxGrid *arg1 = (wxGrid *) 0 ;
17841 void *argp1 = 0 ;
17842 int res1 = 0 ;
17843 PyObject *swig_obj[1] ;
17844
17845 if (!args) SWIG_fail;
17846 swig_obj[0] = args;
17847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17848 if (!SWIG_IsOK(res1)) {
17849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17850 }
17851 arg1 = reinterpret_cast< wxGrid * >(argp1);
17852 {
17853 PyThreadState* __tstate = wxPyBeginAllowThreads();
17854 (arg1)->SelectAll();
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 resultobj = SWIG_Py_Void();
17859 return resultobj;
17860 fail:
17861 return NULL;
17862 }
17863
17864
17865 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17866 PyObject *resultobj = 0;
17867 wxGrid *arg1 = (wxGrid *) 0 ;
17868 bool result;
17869 void *argp1 = 0 ;
17870 int res1 = 0 ;
17871 PyObject *swig_obj[1] ;
17872
17873 if (!args) SWIG_fail;
17874 swig_obj[0] = args;
17875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17876 if (!SWIG_IsOK(res1)) {
17877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17878 }
17879 arg1 = reinterpret_cast< wxGrid * >(argp1);
17880 {
17881 PyThreadState* __tstate = wxPyBeginAllowThreads();
17882 result = (bool)(arg1)->IsSelection();
17883 wxPyEndAllowThreads(__tstate);
17884 if (PyErr_Occurred()) SWIG_fail;
17885 }
17886 {
17887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17888 }
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17896 PyObject *resultobj = 0;
17897 wxGrid *arg1 = (wxGrid *) 0 ;
17898 void *argp1 = 0 ;
17899 int res1 = 0 ;
17900 PyObject *swig_obj[1] ;
17901
17902 if (!args) SWIG_fail;
17903 swig_obj[0] = args;
17904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17905 if (!SWIG_IsOK(res1)) {
17906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17907 }
17908 arg1 = reinterpret_cast< wxGrid * >(argp1);
17909 {
17910 PyThreadState* __tstate = wxPyBeginAllowThreads();
17911 (arg1)->ClearSelection();
17912 wxPyEndAllowThreads(__tstate);
17913 if (PyErr_Occurred()) SWIG_fail;
17914 }
17915 resultobj = SWIG_Py_Void();
17916 return resultobj;
17917 fail:
17918 return NULL;
17919 }
17920
17921
17922 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17923 PyObject *resultobj = 0;
17924 wxGrid *arg1 = (wxGrid *) 0 ;
17925 int arg2 ;
17926 int arg3 ;
17927 bool result;
17928 void *argp1 = 0 ;
17929 int res1 = 0 ;
17930 int val2 ;
17931 int ecode2 = 0 ;
17932 int val3 ;
17933 int ecode3 = 0 ;
17934 PyObject * obj0 = 0 ;
17935 PyObject * obj1 = 0 ;
17936 PyObject * obj2 = 0 ;
17937 char * kwnames[] = {
17938 (char *) "self",(char *) "row",(char *) "col", NULL
17939 };
17940
17941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17945 }
17946 arg1 = reinterpret_cast< wxGrid * >(argp1);
17947 ecode2 = SWIG_AsVal_int(obj1, &val2);
17948 if (!SWIG_IsOK(ecode2)) {
17949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17950 }
17951 arg2 = static_cast< int >(val2);
17952 ecode3 = SWIG_AsVal_int(obj2, &val3);
17953 if (!SWIG_IsOK(ecode3)) {
17954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17955 }
17956 arg3 = static_cast< int >(val3);
17957 {
17958 PyThreadState* __tstate = wxPyBeginAllowThreads();
17959 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 {
17964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17965 }
17966 return resultobj;
17967 fail:
17968 return NULL;
17969 }
17970
17971
17972 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17973 PyObject *resultobj = 0;
17974 wxGrid *arg1 = (wxGrid *) 0 ;
17975 wxGridCellCoordsArray result;
17976 void *argp1 = 0 ;
17977 int res1 = 0 ;
17978 PyObject *swig_obj[1] ;
17979
17980 if (!args) SWIG_fail;
17981 swig_obj[0] = args;
17982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17983 if (!SWIG_IsOK(res1)) {
17984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17985 }
17986 arg1 = reinterpret_cast< wxGrid * >(argp1);
17987 {
17988 PyThreadState* __tstate = wxPyBeginAllowThreads();
17989 result = ((wxGrid const *)arg1)->GetSelectedCells();
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 {
17994 resultobj = wxGridCellCoordsArray_helper(result);
17995 }
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18003 PyObject *resultobj = 0;
18004 wxGrid *arg1 = (wxGrid *) 0 ;
18005 wxGridCellCoordsArray result;
18006 void *argp1 = 0 ;
18007 int res1 = 0 ;
18008 PyObject *swig_obj[1] ;
18009
18010 if (!args) SWIG_fail;
18011 swig_obj[0] = args;
18012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18013 if (!SWIG_IsOK(res1)) {
18014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
18015 }
18016 arg1 = reinterpret_cast< wxGrid * >(argp1);
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 resultobj = wxGridCellCoordsArray_helper(result);
18025 }
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18033 PyObject *resultobj = 0;
18034 wxGrid *arg1 = (wxGrid *) 0 ;
18035 wxGridCellCoordsArray result;
18036 void *argp1 = 0 ;
18037 int res1 = 0 ;
18038 PyObject *swig_obj[1] ;
18039
18040 if (!args) SWIG_fail;
18041 swig_obj[0] = args;
18042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18043 if (!SWIG_IsOK(res1)) {
18044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
18045 }
18046 arg1 = reinterpret_cast< wxGrid * >(argp1);
18047 {
18048 PyThreadState* __tstate = wxPyBeginAllowThreads();
18049 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
18050 wxPyEndAllowThreads(__tstate);
18051 if (PyErr_Occurred()) SWIG_fail;
18052 }
18053 {
18054 resultobj = wxGridCellCoordsArray_helper(result);
18055 }
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063 PyObject *resultobj = 0;
18064 wxGrid *arg1 = (wxGrid *) 0 ;
18065 wxArrayInt result;
18066 void *argp1 = 0 ;
18067 int res1 = 0 ;
18068 PyObject *swig_obj[1] ;
18069
18070 if (!args) SWIG_fail;
18071 swig_obj[0] = args;
18072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18073 if (!SWIG_IsOK(res1)) {
18074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
18075 }
18076 arg1 = reinterpret_cast< wxGrid * >(argp1);
18077 {
18078 PyThreadState* __tstate = wxPyBeginAllowThreads();
18079 result = ((wxGrid const *)arg1)->GetSelectedRows();
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 {
18084 resultobj = wxArrayInt2PyList_helper(result);
18085 }
18086 return resultobj;
18087 fail:
18088 return NULL;
18089 }
18090
18091
18092 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18093 PyObject *resultobj = 0;
18094 wxGrid *arg1 = (wxGrid *) 0 ;
18095 wxArrayInt result;
18096 void *argp1 = 0 ;
18097 int res1 = 0 ;
18098 PyObject *swig_obj[1] ;
18099
18100 if (!args) SWIG_fail;
18101 swig_obj[0] = args;
18102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18103 if (!SWIG_IsOK(res1)) {
18104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
18105 }
18106 arg1 = reinterpret_cast< wxGrid * >(argp1);
18107 {
18108 PyThreadState* __tstate = wxPyBeginAllowThreads();
18109 result = ((wxGrid const *)arg1)->GetSelectedCols();
18110 wxPyEndAllowThreads(__tstate);
18111 if (PyErr_Occurred()) SWIG_fail;
18112 }
18113 {
18114 resultobj = wxArrayInt2PyList_helper(result);
18115 }
18116 return resultobj;
18117 fail:
18118 return NULL;
18119 }
18120
18121
18122 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18123 PyObject *resultobj = 0;
18124 wxGrid *arg1 = (wxGrid *) 0 ;
18125 int arg2 ;
18126 void *argp1 = 0 ;
18127 int res1 = 0 ;
18128 int val2 ;
18129 int ecode2 = 0 ;
18130 PyObject * obj0 = 0 ;
18131 PyObject * obj1 = 0 ;
18132 char * kwnames[] = {
18133 (char *) "self",(char *) "row", NULL
18134 };
18135
18136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
18137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18138 if (!SWIG_IsOK(res1)) {
18139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
18140 }
18141 arg1 = reinterpret_cast< wxGrid * >(argp1);
18142 ecode2 = SWIG_AsVal_int(obj1, &val2);
18143 if (!SWIG_IsOK(ecode2)) {
18144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
18145 }
18146 arg2 = static_cast< int >(val2);
18147 {
18148 PyThreadState* __tstate = wxPyBeginAllowThreads();
18149 (arg1)->DeselectRow(arg2);
18150 wxPyEndAllowThreads(__tstate);
18151 if (PyErr_Occurred()) SWIG_fail;
18152 }
18153 resultobj = SWIG_Py_Void();
18154 return resultobj;
18155 fail:
18156 return NULL;
18157 }
18158
18159
18160 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18161 PyObject *resultobj = 0;
18162 wxGrid *arg1 = (wxGrid *) 0 ;
18163 int arg2 ;
18164 void *argp1 = 0 ;
18165 int res1 = 0 ;
18166 int val2 ;
18167 int ecode2 = 0 ;
18168 PyObject * obj0 = 0 ;
18169 PyObject * obj1 = 0 ;
18170 char * kwnames[] = {
18171 (char *) "self",(char *) "col", NULL
18172 };
18173
18174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
18175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18176 if (!SWIG_IsOK(res1)) {
18177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
18178 }
18179 arg1 = reinterpret_cast< wxGrid * >(argp1);
18180 ecode2 = SWIG_AsVal_int(obj1, &val2);
18181 if (!SWIG_IsOK(ecode2)) {
18182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
18183 }
18184 arg2 = static_cast< int >(val2);
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 (arg1)->DeselectCol(arg2);
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 resultobj = SWIG_Py_Void();
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18199 PyObject *resultobj = 0;
18200 wxGrid *arg1 = (wxGrid *) 0 ;
18201 int arg2 ;
18202 int arg3 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 int val2 ;
18206 int ecode2 = 0 ;
18207 int val3 ;
18208 int ecode3 = 0 ;
18209 PyObject * obj0 = 0 ;
18210 PyObject * obj1 = 0 ;
18211 PyObject * obj2 = 0 ;
18212 char * kwnames[] = {
18213 (char *) "self",(char *) "row",(char *) "col", NULL
18214 };
18215
18216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18218 if (!SWIG_IsOK(res1)) {
18219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
18220 }
18221 arg1 = reinterpret_cast< wxGrid * >(argp1);
18222 ecode2 = SWIG_AsVal_int(obj1, &val2);
18223 if (!SWIG_IsOK(ecode2)) {
18224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
18225 }
18226 arg2 = static_cast< int >(val2);
18227 ecode3 = SWIG_AsVal_int(obj2, &val3);
18228 if (!SWIG_IsOK(ecode3)) {
18229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
18230 }
18231 arg3 = static_cast< int >(val3);
18232 {
18233 PyThreadState* __tstate = wxPyBeginAllowThreads();
18234 (arg1)->DeselectCell(arg2,arg3);
18235 wxPyEndAllowThreads(__tstate);
18236 if (PyErr_Occurred()) SWIG_fail;
18237 }
18238 resultobj = SWIG_Py_Void();
18239 return resultobj;
18240 fail:
18241 return NULL;
18242 }
18243
18244
18245 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18246 PyObject *resultobj = 0;
18247 wxGrid *arg1 = (wxGrid *) 0 ;
18248 wxGridCellCoords *arg2 = 0 ;
18249 wxGridCellCoords *arg3 = 0 ;
18250 wxRect result;
18251 void *argp1 = 0 ;
18252 int res1 = 0 ;
18253 wxGridCellCoords temp2 ;
18254 wxGridCellCoords temp3 ;
18255 PyObject * obj0 = 0 ;
18256 PyObject * obj1 = 0 ;
18257 PyObject * obj2 = 0 ;
18258 char * kwnames[] = {
18259 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
18260 };
18261
18262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18264 if (!SWIG_IsOK(res1)) {
18265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
18266 }
18267 arg1 = reinterpret_cast< wxGrid * >(argp1);
18268 {
18269 arg2 = &temp2;
18270 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
18271 }
18272 {
18273 arg3 = &temp3;
18274 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
18275 }
18276 {
18277 PyThreadState* __tstate = wxPyBeginAllowThreads();
18278 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
18279 wxPyEndAllowThreads(__tstate);
18280 if (PyErr_Occurred()) SWIG_fail;
18281 }
18282 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
18283 return resultobj;
18284 fail:
18285 return NULL;
18286 }
18287
18288
18289 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18290 PyObject *resultobj = 0;
18291 wxGrid *arg1 = (wxGrid *) 0 ;
18292 wxColour result;
18293 void *argp1 = 0 ;
18294 int res1 = 0 ;
18295 PyObject *swig_obj[1] ;
18296
18297 if (!args) SWIG_fail;
18298 swig_obj[0] = args;
18299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18300 if (!SWIG_IsOK(res1)) {
18301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18302 }
18303 arg1 = reinterpret_cast< wxGrid * >(argp1);
18304 {
18305 PyThreadState* __tstate = wxPyBeginAllowThreads();
18306 result = ((wxGrid const *)arg1)->GetSelectionBackground();
18307 wxPyEndAllowThreads(__tstate);
18308 if (PyErr_Occurred()) SWIG_fail;
18309 }
18310 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18311 return resultobj;
18312 fail:
18313 return NULL;
18314 }
18315
18316
18317 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18318 PyObject *resultobj = 0;
18319 wxGrid *arg1 = (wxGrid *) 0 ;
18320 wxColour result;
18321 void *argp1 = 0 ;
18322 int res1 = 0 ;
18323 PyObject *swig_obj[1] ;
18324
18325 if (!args) SWIG_fail;
18326 swig_obj[0] = args;
18327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18328 if (!SWIG_IsOK(res1)) {
18329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
18330 }
18331 arg1 = reinterpret_cast< wxGrid * >(argp1);
18332 {
18333 PyThreadState* __tstate = wxPyBeginAllowThreads();
18334 result = ((wxGrid const *)arg1)->GetSelectionForeground();
18335 wxPyEndAllowThreads(__tstate);
18336 if (PyErr_Occurred()) SWIG_fail;
18337 }
18338 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
18339 return resultobj;
18340 fail:
18341 return NULL;
18342 }
18343
18344
18345 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18346 PyObject *resultobj = 0;
18347 wxGrid *arg1 = (wxGrid *) 0 ;
18348 wxColour *arg2 = 0 ;
18349 void *argp1 = 0 ;
18350 int res1 = 0 ;
18351 wxColour temp2 ;
18352 PyObject * obj0 = 0 ;
18353 PyObject * obj1 = 0 ;
18354 char * kwnames[] = {
18355 (char *) "self",(char *) "c", NULL
18356 };
18357
18358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
18359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18360 if (!SWIG_IsOK(res1)) {
18361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
18362 }
18363 arg1 = reinterpret_cast< wxGrid * >(argp1);
18364 {
18365 arg2 = &temp2;
18366 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18367 }
18368 {
18369 PyThreadState* __tstate = wxPyBeginAllowThreads();
18370 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
18371 wxPyEndAllowThreads(__tstate);
18372 if (PyErr_Occurred()) SWIG_fail;
18373 }
18374 resultobj = SWIG_Py_Void();
18375 return resultobj;
18376 fail:
18377 return NULL;
18378 }
18379
18380
18381 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18382 PyObject *resultobj = 0;
18383 wxGrid *arg1 = (wxGrid *) 0 ;
18384 wxColour *arg2 = 0 ;
18385 void *argp1 = 0 ;
18386 int res1 = 0 ;
18387 wxColour temp2 ;
18388 PyObject * obj0 = 0 ;
18389 PyObject * obj1 = 0 ;
18390 char * kwnames[] = {
18391 (char *) "self",(char *) "c", NULL
18392 };
18393
18394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
18395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18396 if (!SWIG_IsOK(res1)) {
18397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
18398 }
18399 arg1 = reinterpret_cast< wxGrid * >(argp1);
18400 {
18401 arg2 = &temp2;
18402 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
18403 }
18404 {
18405 PyThreadState* __tstate = wxPyBeginAllowThreads();
18406 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
18407 wxPyEndAllowThreads(__tstate);
18408 if (PyErr_Occurred()) SWIG_fail;
18409 }
18410 resultobj = SWIG_Py_Void();
18411 return resultobj;
18412 fail:
18413 return NULL;
18414 }
18415
18416
18417 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18418 PyObject *resultobj = 0;
18419 wxGrid *arg1 = (wxGrid *) 0 ;
18420 wxString *arg2 = 0 ;
18421 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
18422 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
18423 void *argp1 = 0 ;
18424 int res1 = 0 ;
18425 bool temp2 = false ;
18426 void *argp3 = 0 ;
18427 int res3 = 0 ;
18428 void *argp4 = 0 ;
18429 int res4 = 0 ;
18430 PyObject * obj0 = 0 ;
18431 PyObject * obj1 = 0 ;
18432 PyObject * obj2 = 0 ;
18433 PyObject * obj3 = 0 ;
18434 char * kwnames[] = {
18435 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
18436 };
18437
18438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18440 if (!SWIG_IsOK(res1)) {
18441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
18442 }
18443 arg1 = reinterpret_cast< wxGrid * >(argp1);
18444 {
18445 arg2 = wxString_in_helper(obj1);
18446 if (arg2 == NULL) SWIG_fail;
18447 temp2 = true;
18448 }
18449 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
18450 if (!SWIG_IsOK(res3)) {
18451 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
18452 }
18453 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
18454 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
18455 if (!SWIG_IsOK(res4)) {
18456 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
18457 }
18458 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
18459 {
18460 PyThreadState* __tstate = wxPyBeginAllowThreads();
18461 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 resultobj = SWIG_Py_Void();
18466 {
18467 if (temp2)
18468 delete arg2;
18469 }
18470 return resultobj;
18471 fail:
18472 {
18473 if (temp2)
18474 delete arg2;
18475 }
18476 return NULL;
18477 }
18478
18479
18480 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj = 0;
18482 wxGrid *arg1 = (wxGrid *) 0 ;
18483 int arg2 ;
18484 int arg3 ;
18485 wxGridCellEditor *result = 0 ;
18486 void *argp1 = 0 ;
18487 int res1 = 0 ;
18488 int val2 ;
18489 int ecode2 = 0 ;
18490 int val3 ;
18491 int ecode3 = 0 ;
18492 PyObject * obj0 = 0 ;
18493 PyObject * obj1 = 0 ;
18494 PyObject * obj2 = 0 ;
18495 char * kwnames[] = {
18496 (char *) "self",(char *) "row",(char *) "col", NULL
18497 };
18498
18499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18501 if (!SWIG_IsOK(res1)) {
18502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18503 }
18504 arg1 = reinterpret_cast< wxGrid * >(argp1);
18505 ecode2 = SWIG_AsVal_int(obj1, &val2);
18506 if (!SWIG_IsOK(ecode2)) {
18507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
18508 }
18509 arg2 = static_cast< int >(val2);
18510 ecode3 = SWIG_AsVal_int(obj2, &val3);
18511 if (!SWIG_IsOK(ecode3)) {
18512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
18513 }
18514 arg3 = static_cast< int >(val3);
18515 {
18516 PyThreadState* __tstate = wxPyBeginAllowThreads();
18517 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 {
18522 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj = 0;
18532 wxGrid *arg1 = (wxGrid *) 0 ;
18533 int arg2 ;
18534 int arg3 ;
18535 wxGridCellRenderer *result = 0 ;
18536 void *argp1 = 0 ;
18537 int res1 = 0 ;
18538 int val2 ;
18539 int ecode2 = 0 ;
18540 int val3 ;
18541 int ecode3 = 0 ;
18542 PyObject * obj0 = 0 ;
18543 PyObject * obj1 = 0 ;
18544 PyObject * obj2 = 0 ;
18545 char * kwnames[] = {
18546 (char *) "self",(char *) "row",(char *) "col", NULL
18547 };
18548
18549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18551 if (!SWIG_IsOK(res1)) {
18552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
18553 }
18554 arg1 = reinterpret_cast< wxGrid * >(argp1);
18555 ecode2 = SWIG_AsVal_int(obj1, &val2);
18556 if (!SWIG_IsOK(ecode2)) {
18557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
18558 }
18559 arg2 = static_cast< int >(val2);
18560 ecode3 = SWIG_AsVal_int(obj2, &val3);
18561 if (!SWIG_IsOK(ecode3)) {
18562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
18563 }
18564 arg3 = static_cast< int >(val3);
18565 {
18566 PyThreadState* __tstate = wxPyBeginAllowThreads();
18567 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
18568 wxPyEndAllowThreads(__tstate);
18569 if (PyErr_Occurred()) SWIG_fail;
18570 }
18571 {
18572 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18573 }
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18581 PyObject *resultobj = 0;
18582 wxGrid *arg1 = (wxGrid *) 0 ;
18583 wxString *arg2 = 0 ;
18584 wxGridCellEditor *result = 0 ;
18585 void *argp1 = 0 ;
18586 int res1 = 0 ;
18587 bool temp2 = false ;
18588 PyObject * obj0 = 0 ;
18589 PyObject * obj1 = 0 ;
18590 char * kwnames[] = {
18591 (char *) "self",(char *) "typeName", NULL
18592 };
18593
18594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
18595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18596 if (!SWIG_IsOK(res1)) {
18597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18598 }
18599 arg1 = reinterpret_cast< wxGrid * >(argp1);
18600 {
18601 arg2 = wxString_in_helper(obj1);
18602 if (arg2 == NULL) SWIG_fail;
18603 temp2 = true;
18604 }
18605 {
18606 PyThreadState* __tstate = wxPyBeginAllowThreads();
18607 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18608 wxPyEndAllowThreads(__tstate);
18609 if (PyErr_Occurred()) SWIG_fail;
18610 }
18611 {
18612 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18613 }
18614 {
18615 if (temp2)
18616 delete arg2;
18617 }
18618 return resultobj;
18619 fail:
18620 {
18621 if (temp2)
18622 delete arg2;
18623 }
18624 return NULL;
18625 }
18626
18627
18628 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18629 PyObject *resultobj = 0;
18630 wxGrid *arg1 = (wxGrid *) 0 ;
18631 wxString *arg2 = 0 ;
18632 wxGridCellRenderer *result = 0 ;
18633 void *argp1 = 0 ;
18634 int res1 = 0 ;
18635 bool temp2 = false ;
18636 PyObject * obj0 = 0 ;
18637 PyObject * obj1 = 0 ;
18638 char * kwnames[] = {
18639 (char *) "self",(char *) "typeName", NULL
18640 };
18641
18642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18644 if (!SWIG_IsOK(res1)) {
18645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18646 }
18647 arg1 = reinterpret_cast< wxGrid * >(argp1);
18648 {
18649 arg2 = wxString_in_helper(obj1);
18650 if (arg2 == NULL) SWIG_fail;
18651 temp2 = true;
18652 }
18653 {
18654 PyThreadState* __tstate = wxPyBeginAllowThreads();
18655 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18656 wxPyEndAllowThreads(__tstate);
18657 if (PyErr_Occurred()) SWIG_fail;
18658 }
18659 {
18660 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18661 }
18662 {
18663 if (temp2)
18664 delete arg2;
18665 }
18666 return resultobj;
18667 fail:
18668 {
18669 if (temp2)
18670 delete arg2;
18671 }
18672 return NULL;
18673 }
18674
18675
18676 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18677 PyObject *resultobj = 0;
18678 wxGrid *arg1 = (wxGrid *) 0 ;
18679 int arg2 ;
18680 int arg3 ;
18681 void *argp1 = 0 ;
18682 int res1 = 0 ;
18683 int val2 ;
18684 int ecode2 = 0 ;
18685 int val3 ;
18686 int ecode3 = 0 ;
18687 PyObject * obj0 = 0 ;
18688 PyObject * obj1 = 0 ;
18689 PyObject * obj2 = 0 ;
18690 char * kwnames[] = {
18691 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18692 };
18693
18694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18696 if (!SWIG_IsOK(res1)) {
18697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18698 }
18699 arg1 = reinterpret_cast< wxGrid * >(argp1);
18700 ecode2 = SWIG_AsVal_int(obj1, &val2);
18701 if (!SWIG_IsOK(ecode2)) {
18702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18703 }
18704 arg2 = static_cast< int >(val2);
18705 ecode3 = SWIG_AsVal_int(obj2, &val3);
18706 if (!SWIG_IsOK(ecode3)) {
18707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18708 }
18709 arg3 = static_cast< int >(val3);
18710 {
18711 PyThreadState* __tstate = wxPyBeginAllowThreads();
18712 (arg1)->SetMargins(arg2,arg3);
18713 wxPyEndAllowThreads(__tstate);
18714 if (PyErr_Occurred()) SWIG_fail;
18715 }
18716 resultobj = SWIG_Py_Void();
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18724 PyObject *resultobj = 0;
18725 wxGrid *arg1 = (wxGrid *) 0 ;
18726 wxWindow *result = 0 ;
18727 void *argp1 = 0 ;
18728 int res1 = 0 ;
18729 PyObject *swig_obj[1] ;
18730
18731 if (!args) SWIG_fail;
18732 swig_obj[0] = args;
18733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18734 if (!SWIG_IsOK(res1)) {
18735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18736 }
18737 arg1 = reinterpret_cast< wxGrid * >(argp1);
18738 {
18739 PyThreadState* __tstate = wxPyBeginAllowThreads();
18740 result = (wxWindow *)(arg1)->GetGridWindow();
18741 wxPyEndAllowThreads(__tstate);
18742 if (PyErr_Occurred()) SWIG_fail;
18743 }
18744 {
18745 resultobj = wxPyMake_wxObject(result, 0);
18746 }
18747 return resultobj;
18748 fail:
18749 return NULL;
18750 }
18751
18752
18753 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18754 PyObject *resultobj = 0;
18755 wxGrid *arg1 = (wxGrid *) 0 ;
18756 wxWindow *result = 0 ;
18757 void *argp1 = 0 ;
18758 int res1 = 0 ;
18759 PyObject *swig_obj[1] ;
18760
18761 if (!args) SWIG_fail;
18762 swig_obj[0] = args;
18763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18764 if (!SWIG_IsOK(res1)) {
18765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18766 }
18767 arg1 = reinterpret_cast< wxGrid * >(argp1);
18768 {
18769 PyThreadState* __tstate = wxPyBeginAllowThreads();
18770 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18771 wxPyEndAllowThreads(__tstate);
18772 if (PyErr_Occurred()) SWIG_fail;
18773 }
18774 {
18775 resultobj = wxPyMake_wxObject(result, 0);
18776 }
18777 return resultobj;
18778 fail:
18779 return NULL;
18780 }
18781
18782
18783 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18784 PyObject *resultobj = 0;
18785 wxGrid *arg1 = (wxGrid *) 0 ;
18786 wxWindow *result = 0 ;
18787 void *argp1 = 0 ;
18788 int res1 = 0 ;
18789 PyObject *swig_obj[1] ;
18790
18791 if (!args) SWIG_fail;
18792 swig_obj[0] = args;
18793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18794 if (!SWIG_IsOK(res1)) {
18795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18796 }
18797 arg1 = reinterpret_cast< wxGrid * >(argp1);
18798 {
18799 PyThreadState* __tstate = wxPyBeginAllowThreads();
18800 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18801 wxPyEndAllowThreads(__tstate);
18802 if (PyErr_Occurred()) SWIG_fail;
18803 }
18804 {
18805 resultobj = wxPyMake_wxObject(result, 0);
18806 }
18807 return resultobj;
18808 fail:
18809 return NULL;
18810 }
18811
18812
18813 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18814 PyObject *resultobj = 0;
18815 wxGrid *arg1 = (wxGrid *) 0 ;
18816 wxWindow *result = 0 ;
18817 void *argp1 = 0 ;
18818 int res1 = 0 ;
18819 PyObject *swig_obj[1] ;
18820
18821 if (!args) SWIG_fail;
18822 swig_obj[0] = args;
18823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18824 if (!SWIG_IsOK(res1)) {
18825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18826 }
18827 arg1 = reinterpret_cast< wxGrid * >(argp1);
18828 {
18829 PyThreadState* __tstate = wxPyBeginAllowThreads();
18830 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18831 wxPyEndAllowThreads(__tstate);
18832 if (PyErr_Occurred()) SWIG_fail;
18833 }
18834 {
18835 resultobj = wxPyMake_wxObject(result, 0);
18836 }
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 wxGrid *arg1 = (wxGrid *) 0 ;
18846 int arg2 ;
18847 void *argp1 = 0 ;
18848 int res1 = 0 ;
18849 int val2 ;
18850 int ecode2 = 0 ;
18851 PyObject * obj0 = 0 ;
18852 PyObject * obj1 = 0 ;
18853 char * kwnames[] = {
18854 (char *) "self",(char *) "x", NULL
18855 };
18856
18857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18859 if (!SWIG_IsOK(res1)) {
18860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18861 }
18862 arg1 = reinterpret_cast< wxGrid * >(argp1);
18863 ecode2 = SWIG_AsVal_int(obj1, &val2);
18864 if (!SWIG_IsOK(ecode2)) {
18865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18866 }
18867 arg2 = static_cast< int >(val2);
18868 {
18869 PyThreadState* __tstate = wxPyBeginAllowThreads();
18870 (arg1)->SetScrollLineX(arg2);
18871 wxPyEndAllowThreads(__tstate);
18872 if (PyErr_Occurred()) SWIG_fail;
18873 }
18874 resultobj = SWIG_Py_Void();
18875 return resultobj;
18876 fail:
18877 return NULL;
18878 }
18879
18880
18881 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18882 PyObject *resultobj = 0;
18883 wxGrid *arg1 = (wxGrid *) 0 ;
18884 int arg2 ;
18885 void *argp1 = 0 ;
18886 int res1 = 0 ;
18887 int val2 ;
18888 int ecode2 = 0 ;
18889 PyObject * obj0 = 0 ;
18890 PyObject * obj1 = 0 ;
18891 char * kwnames[] = {
18892 (char *) "self",(char *) "y", NULL
18893 };
18894
18895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18897 if (!SWIG_IsOK(res1)) {
18898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18899 }
18900 arg1 = reinterpret_cast< wxGrid * >(argp1);
18901 ecode2 = SWIG_AsVal_int(obj1, &val2);
18902 if (!SWIG_IsOK(ecode2)) {
18903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18904 }
18905 arg2 = static_cast< int >(val2);
18906 {
18907 PyThreadState* __tstate = wxPyBeginAllowThreads();
18908 (arg1)->SetScrollLineY(arg2);
18909 wxPyEndAllowThreads(__tstate);
18910 if (PyErr_Occurred()) SWIG_fail;
18911 }
18912 resultobj = SWIG_Py_Void();
18913 return resultobj;
18914 fail:
18915 return NULL;
18916 }
18917
18918
18919 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18920 PyObject *resultobj = 0;
18921 wxGrid *arg1 = (wxGrid *) 0 ;
18922 int result;
18923 void *argp1 = 0 ;
18924 int res1 = 0 ;
18925 PyObject *swig_obj[1] ;
18926
18927 if (!args) SWIG_fail;
18928 swig_obj[0] = args;
18929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18930 if (!SWIG_IsOK(res1)) {
18931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18932 }
18933 arg1 = reinterpret_cast< wxGrid * >(argp1);
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18937 wxPyEndAllowThreads(__tstate);
18938 if (PyErr_Occurred()) SWIG_fail;
18939 }
18940 resultobj = SWIG_From_int(static_cast< int >(result));
18941 return resultobj;
18942 fail:
18943 return NULL;
18944 }
18945
18946
18947 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18948 PyObject *resultobj = 0;
18949 wxGrid *arg1 = (wxGrid *) 0 ;
18950 int result;
18951 void *argp1 = 0 ;
18952 int res1 = 0 ;
18953 PyObject *swig_obj[1] ;
18954
18955 if (!args) SWIG_fail;
18956 swig_obj[0] = args;
18957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18958 if (!SWIG_IsOK(res1)) {
18959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18960 }
18961 arg1 = reinterpret_cast< wxGrid * >(argp1);
18962 {
18963 PyThreadState* __tstate = wxPyBeginAllowThreads();
18964 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18965 wxPyEndAllowThreads(__tstate);
18966 if (PyErr_Occurred()) SWIG_fail;
18967 }
18968 resultobj = SWIG_From_int(static_cast< int >(result));
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj = 0;
18977 wxGrid *arg1 = (wxGrid *) 0 ;
18978 int arg2 ;
18979 int result;
18980 void *argp1 = 0 ;
18981 int res1 = 0 ;
18982 int val2 ;
18983 int ecode2 = 0 ;
18984 PyObject * obj0 = 0 ;
18985 PyObject * obj1 = 0 ;
18986 char * kwnames[] = {
18987 (char *) "self",(char *) "x", NULL
18988 };
18989
18990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18992 if (!SWIG_IsOK(res1)) {
18993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18994 }
18995 arg1 = reinterpret_cast< wxGrid * >(argp1);
18996 ecode2 = SWIG_AsVal_int(obj1, &val2);
18997 if (!SWIG_IsOK(ecode2)) {
18998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18999 }
19000 arg2 = static_cast< int >(val2);
19001 {
19002 PyThreadState* __tstate = wxPyBeginAllowThreads();
19003 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
19004 wxPyEndAllowThreads(__tstate);
19005 if (PyErr_Occurred()) SWIG_fail;
19006 }
19007 resultobj = SWIG_From_int(static_cast< int >(result));
19008 return resultobj;
19009 fail:
19010 return NULL;
19011 }
19012
19013
19014 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19015 PyObject *resultobj = 0;
19016 wxGrid *arg1 = (wxGrid *) 0 ;
19017 int arg2 ;
19018 int result;
19019 void *argp1 = 0 ;
19020 int res1 = 0 ;
19021 int val2 ;
19022 int ecode2 = 0 ;
19023 PyObject * obj0 = 0 ;
19024 PyObject * obj1 = 0 ;
19025 char * kwnames[] = {
19026 (char *) "self",(char *) "y", NULL
19027 };
19028
19029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
19030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
19031 if (!SWIG_IsOK(res1)) {
19032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
19033 }
19034 arg1 = reinterpret_cast< wxGrid * >(argp1);
19035 ecode2 = SWIG_AsVal_int(obj1, &val2);
19036 if (!SWIG_IsOK(ecode2)) {
19037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
19038 }
19039 arg2 = static_cast< int >(val2);
19040 {
19041 PyThreadState* __tstate = wxPyBeginAllowThreads();
19042 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
19043 wxPyEndAllowThreads(__tstate);
19044 if (PyErr_Occurred()) SWIG_fail;
19045 }
19046 resultobj = SWIG_From_int(static_cast< int >(result));
19047 return resultobj;
19048 fail:
19049 return NULL;
19050 }
19051
19052
19053 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19054 PyObject *resultobj = 0;
19055 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
19056 SwigValueWrapper<wxVisualAttributes > result;
19057 int val1 ;
19058 int ecode1 = 0 ;
19059 PyObject * obj0 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "variant", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
19065 if (obj0) {
19066 ecode1 = SWIG_AsVal_int(obj0, &val1);
19067 if (!SWIG_IsOK(ecode1)) {
19068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
19069 }
19070 arg1 = static_cast< wxWindowVariant >(val1);
19071 }
19072 {
19073 if (!wxPyCheckForApp()) SWIG_fail;
19074 PyThreadState* __tstate = wxPyBeginAllowThreads();
19075 result = wxGrid::GetClassDefaultAttributes(arg1);
19076 wxPyEndAllowThreads(__tstate);
19077 if (PyErr_Occurred()) SWIG_fail;
19078 }
19079 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
19080 return resultobj;
19081 fail:
19082 return NULL;
19083 }
19084
19085
19086 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19087 PyObject *obj;
19088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19089 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
19090 return SWIG_Py_Void();
19091 }
19092
19093 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19094 return SWIG_Python_InitShadowInstance(args);
19095 }
19096
19097 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj = 0;
19099 int arg1 ;
19100 wxEventType arg2 ;
19101 wxGrid *arg3 = (wxGrid *) 0 ;
19102 int arg4 = (int) -1 ;
19103 int arg5 = (int) -1 ;
19104 int arg6 = (int) -1 ;
19105 int arg7 = (int) -1 ;
19106 bool arg8 = (bool) true ;
19107 bool arg9 = (bool) false ;
19108 bool arg10 = (bool) false ;
19109 bool arg11 = (bool) false ;
19110 bool arg12 = (bool) false ;
19111 wxGridEvent *result = 0 ;
19112 int val1 ;
19113 int ecode1 = 0 ;
19114 int val2 ;
19115 int ecode2 = 0 ;
19116 void *argp3 = 0 ;
19117 int res3 = 0 ;
19118 int val4 ;
19119 int ecode4 = 0 ;
19120 int val5 ;
19121 int ecode5 = 0 ;
19122 int val6 ;
19123 int ecode6 = 0 ;
19124 int val7 ;
19125 int ecode7 = 0 ;
19126 bool val8 ;
19127 int ecode8 = 0 ;
19128 bool val9 ;
19129 int ecode9 = 0 ;
19130 bool val10 ;
19131 int ecode10 = 0 ;
19132 bool val11 ;
19133 int ecode11 = 0 ;
19134 bool val12 ;
19135 int ecode12 = 0 ;
19136 PyObject * obj0 = 0 ;
19137 PyObject * obj1 = 0 ;
19138 PyObject * obj2 = 0 ;
19139 PyObject * obj3 = 0 ;
19140 PyObject * obj4 = 0 ;
19141 PyObject * obj5 = 0 ;
19142 PyObject * obj6 = 0 ;
19143 PyObject * obj7 = 0 ;
19144 PyObject * obj8 = 0 ;
19145 PyObject * obj9 = 0 ;
19146 PyObject * obj10 = 0 ;
19147 PyObject * obj11 = 0 ;
19148 char * kwnames[] = {
19149 (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
19150 };
19151
19152 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;
19153 ecode1 = SWIG_AsVal_int(obj0, &val1);
19154 if (!SWIG_IsOK(ecode1)) {
19155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
19156 }
19157 arg1 = static_cast< int >(val1);
19158 ecode2 = SWIG_AsVal_int(obj1, &val2);
19159 if (!SWIG_IsOK(ecode2)) {
19160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19161 }
19162 arg2 = static_cast< wxEventType >(val2);
19163 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19164 if (!SWIG_IsOK(res3)) {
19165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19166 }
19167 arg3 = reinterpret_cast< wxGrid * >(argp3);
19168 if (obj3) {
19169 ecode4 = SWIG_AsVal_int(obj3, &val4);
19170 if (!SWIG_IsOK(ecode4)) {
19171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
19172 }
19173 arg4 = static_cast< int >(val4);
19174 }
19175 if (obj4) {
19176 ecode5 = SWIG_AsVal_int(obj4, &val5);
19177 if (!SWIG_IsOK(ecode5)) {
19178 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
19179 }
19180 arg5 = static_cast< int >(val5);
19181 }
19182 if (obj5) {
19183 ecode6 = SWIG_AsVal_int(obj5, &val6);
19184 if (!SWIG_IsOK(ecode6)) {
19185 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
19186 }
19187 arg6 = static_cast< int >(val6);
19188 }
19189 if (obj6) {
19190 ecode7 = SWIG_AsVal_int(obj6, &val7);
19191 if (!SWIG_IsOK(ecode7)) {
19192 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
19193 }
19194 arg7 = static_cast< int >(val7);
19195 }
19196 if (obj7) {
19197 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19198 if (!SWIG_IsOK(ecode8)) {
19199 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
19200 }
19201 arg8 = static_cast< bool >(val8);
19202 }
19203 if (obj8) {
19204 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19205 if (!SWIG_IsOK(ecode9)) {
19206 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
19207 }
19208 arg9 = static_cast< bool >(val9);
19209 }
19210 if (obj9) {
19211 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19212 if (!SWIG_IsOK(ecode10)) {
19213 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
19214 }
19215 arg10 = static_cast< bool >(val10);
19216 }
19217 if (obj10) {
19218 ecode11 = SWIG_AsVal_bool(obj10, &val11);
19219 if (!SWIG_IsOK(ecode11)) {
19220 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
19221 }
19222 arg11 = static_cast< bool >(val11);
19223 }
19224 if (obj11) {
19225 ecode12 = SWIG_AsVal_bool(obj11, &val12);
19226 if (!SWIG_IsOK(ecode12)) {
19227 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
19228 }
19229 arg12 = static_cast< bool >(val12);
19230 }
19231 {
19232 PyThreadState* __tstate = wxPyBeginAllowThreads();
19233 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19245 PyObject *resultobj = 0;
19246 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19247 int result;
19248 void *argp1 = 0 ;
19249 int res1 = 0 ;
19250 PyObject *swig_obj[1] ;
19251
19252 if (!args) SWIG_fail;
19253 swig_obj[0] = args;
19254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19255 if (!SWIG_IsOK(res1)) {
19256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19257 }
19258 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19259 {
19260 PyThreadState* __tstate = wxPyBeginAllowThreads();
19261 result = (int)(arg1)->GetRow();
19262 wxPyEndAllowThreads(__tstate);
19263 if (PyErr_Occurred()) SWIG_fail;
19264 }
19265 resultobj = SWIG_From_int(static_cast< int >(result));
19266 return resultobj;
19267 fail:
19268 return NULL;
19269 }
19270
19271
19272 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19273 PyObject *resultobj = 0;
19274 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19275 int result;
19276 void *argp1 = 0 ;
19277 int res1 = 0 ;
19278 PyObject *swig_obj[1] ;
19279
19280 if (!args) SWIG_fail;
19281 swig_obj[0] = args;
19282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19283 if (!SWIG_IsOK(res1)) {
19284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19285 }
19286 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19287 {
19288 PyThreadState* __tstate = wxPyBeginAllowThreads();
19289 result = (int)(arg1)->GetCol();
19290 wxPyEndAllowThreads(__tstate);
19291 if (PyErr_Occurred()) SWIG_fail;
19292 }
19293 resultobj = SWIG_From_int(static_cast< int >(result));
19294 return resultobj;
19295 fail:
19296 return NULL;
19297 }
19298
19299
19300 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19301 PyObject *resultobj = 0;
19302 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19303 wxPoint result;
19304 void *argp1 = 0 ;
19305 int res1 = 0 ;
19306 PyObject *swig_obj[1] ;
19307
19308 if (!args) SWIG_fail;
19309 swig_obj[0] = args;
19310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19311 if (!SWIG_IsOK(res1)) {
19312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19313 }
19314 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19315 {
19316 PyThreadState* __tstate = wxPyBeginAllowThreads();
19317 result = (arg1)->GetPosition();
19318 wxPyEndAllowThreads(__tstate);
19319 if (PyErr_Occurred()) SWIG_fail;
19320 }
19321 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19329 PyObject *resultobj = 0;
19330 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19331 bool result;
19332 void *argp1 = 0 ;
19333 int res1 = 0 ;
19334 PyObject *swig_obj[1] ;
19335
19336 if (!args) SWIG_fail;
19337 swig_obj[0] = args;
19338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19339 if (!SWIG_IsOK(res1)) {
19340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19341 }
19342 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = (bool)(arg1)->Selecting();
19346 wxPyEndAllowThreads(__tstate);
19347 if (PyErr_Occurred()) SWIG_fail;
19348 }
19349 {
19350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19351 }
19352 return resultobj;
19353 fail:
19354 return NULL;
19355 }
19356
19357
19358 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19359 PyObject *resultobj = 0;
19360 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19361 bool 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_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19371 }
19372 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = (bool)(arg1)->ControlDown();
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 {
19380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19381 }
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19389 PyObject *resultobj = 0;
19390 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19391 bool result;
19392 void *argp1 = 0 ;
19393 int res1 = 0 ;
19394 PyObject *swig_obj[1] ;
19395
19396 if (!args) SWIG_fail;
19397 swig_obj[0] = args;
19398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19399 if (!SWIG_IsOK(res1)) {
19400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19401 }
19402 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19403 {
19404 PyThreadState* __tstate = wxPyBeginAllowThreads();
19405 result = (bool)(arg1)->MetaDown();
19406 wxPyEndAllowThreads(__tstate);
19407 if (PyErr_Occurred()) SWIG_fail;
19408 }
19409 {
19410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19411 }
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19419 PyObject *resultobj = 0;
19420 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19421 bool result;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 PyObject *swig_obj[1] ;
19425
19426 if (!args) SWIG_fail;
19427 swig_obj[0] = args;
19428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19429 if (!SWIG_IsOK(res1)) {
19430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19431 }
19432 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 result = (bool)(arg1)->ShiftDown();
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 {
19440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19441 }
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449 PyObject *resultobj = 0;
19450 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19451 bool result;
19452 void *argp1 = 0 ;
19453 int res1 = 0 ;
19454 PyObject *swig_obj[1] ;
19455
19456 if (!args) SWIG_fail;
19457 swig_obj[0] = args;
19458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19459 if (!SWIG_IsOK(res1)) {
19460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19461 }
19462 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = (bool)(arg1)->AltDown();
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 {
19470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19471 }
19472 return resultobj;
19473 fail:
19474 return NULL;
19475 }
19476
19477
19478 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19479 PyObject *resultobj = 0;
19480 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
19481 bool result;
19482 void *argp1 = 0 ;
19483 int res1 = 0 ;
19484 PyObject *swig_obj[1] ;
19485
19486 if (!args) SWIG_fail;
19487 swig_obj[0] = args;
19488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
19489 if (!SWIG_IsOK(res1)) {
19490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
19491 }
19492 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
19493 {
19494 PyThreadState* __tstate = wxPyBeginAllowThreads();
19495 result = (bool)(arg1)->CmdDown();
19496 wxPyEndAllowThreads(__tstate);
19497 if (PyErr_Occurred()) SWIG_fail;
19498 }
19499 {
19500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19501 }
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19509 PyObject *obj;
19510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19511 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
19512 return SWIG_Py_Void();
19513 }
19514
19515 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19516 return SWIG_Python_InitShadowInstance(args);
19517 }
19518
19519 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19520 PyObject *resultobj = 0;
19521 int arg1 ;
19522 wxEventType arg2 ;
19523 wxGrid *arg3 = (wxGrid *) 0 ;
19524 int arg4 = (int) -1 ;
19525 int arg5 = (int) -1 ;
19526 int arg6 = (int) -1 ;
19527 bool arg7 = (bool) false ;
19528 bool arg8 = (bool) false ;
19529 bool arg9 = (bool) false ;
19530 bool arg10 = (bool) false ;
19531 wxGridSizeEvent *result = 0 ;
19532 int val1 ;
19533 int ecode1 = 0 ;
19534 int val2 ;
19535 int ecode2 = 0 ;
19536 void *argp3 = 0 ;
19537 int res3 = 0 ;
19538 int val4 ;
19539 int ecode4 = 0 ;
19540 int val5 ;
19541 int ecode5 = 0 ;
19542 int val6 ;
19543 int ecode6 = 0 ;
19544 bool val7 ;
19545 int ecode7 = 0 ;
19546 bool val8 ;
19547 int ecode8 = 0 ;
19548 bool val9 ;
19549 int ecode9 = 0 ;
19550 bool val10 ;
19551 int ecode10 = 0 ;
19552 PyObject * obj0 = 0 ;
19553 PyObject * obj1 = 0 ;
19554 PyObject * obj2 = 0 ;
19555 PyObject * obj3 = 0 ;
19556 PyObject * obj4 = 0 ;
19557 PyObject * obj5 = 0 ;
19558 PyObject * obj6 = 0 ;
19559 PyObject * obj7 = 0 ;
19560 PyObject * obj8 = 0 ;
19561 PyObject * obj9 = 0 ;
19562 char * kwnames[] = {
19563 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19564 };
19565
19566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19567 ecode1 = SWIG_AsVal_int(obj0, &val1);
19568 if (!SWIG_IsOK(ecode1)) {
19569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
19570 }
19571 arg1 = static_cast< int >(val1);
19572 ecode2 = SWIG_AsVal_int(obj1, &val2);
19573 if (!SWIG_IsOK(ecode2)) {
19574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19575 }
19576 arg2 = static_cast< wxEventType >(val2);
19577 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19578 if (!SWIG_IsOK(res3)) {
19579 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19580 }
19581 arg3 = reinterpret_cast< wxGrid * >(argp3);
19582 if (obj3) {
19583 ecode4 = SWIG_AsVal_int(obj3, &val4);
19584 if (!SWIG_IsOK(ecode4)) {
19585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
19586 }
19587 arg4 = static_cast< int >(val4);
19588 }
19589 if (obj4) {
19590 ecode5 = SWIG_AsVal_int(obj4, &val5);
19591 if (!SWIG_IsOK(ecode5)) {
19592 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
19593 }
19594 arg5 = static_cast< int >(val5);
19595 }
19596 if (obj5) {
19597 ecode6 = SWIG_AsVal_int(obj5, &val6);
19598 if (!SWIG_IsOK(ecode6)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19600 }
19601 arg6 = static_cast< int >(val6);
19602 }
19603 if (obj6) {
19604 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19605 if (!SWIG_IsOK(ecode7)) {
19606 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19607 }
19608 arg7 = static_cast< bool >(val7);
19609 }
19610 if (obj7) {
19611 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19612 if (!SWIG_IsOK(ecode8)) {
19613 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19614 }
19615 arg8 = static_cast< bool >(val8);
19616 }
19617 if (obj8) {
19618 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19619 if (!SWIG_IsOK(ecode9)) {
19620 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19621 }
19622 arg9 = static_cast< bool >(val9);
19623 }
19624 if (obj9) {
19625 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19626 if (!SWIG_IsOK(ecode10)) {
19627 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19628 }
19629 arg10 = static_cast< bool >(val10);
19630 }
19631 {
19632 PyThreadState* __tstate = wxPyBeginAllowThreads();
19633 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19634 wxPyEndAllowThreads(__tstate);
19635 if (PyErr_Occurred()) SWIG_fail;
19636 }
19637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19638 return resultobj;
19639 fail:
19640 return NULL;
19641 }
19642
19643
19644 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 PyObject *resultobj = 0;
19646 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19647 int result;
19648 void *argp1 = 0 ;
19649 int res1 = 0 ;
19650 PyObject *swig_obj[1] ;
19651
19652 if (!args) SWIG_fail;
19653 swig_obj[0] = args;
19654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19655 if (!SWIG_IsOK(res1)) {
19656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19657 }
19658 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19659 {
19660 PyThreadState* __tstate = wxPyBeginAllowThreads();
19661 result = (int)(arg1)->GetRowOrCol();
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 resultobj = SWIG_From_int(static_cast< int >(result));
19666 return resultobj;
19667 fail:
19668 return NULL;
19669 }
19670
19671
19672 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19673 PyObject *resultobj = 0;
19674 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19675 wxPoint result;
19676 void *argp1 = 0 ;
19677 int res1 = 0 ;
19678 PyObject *swig_obj[1] ;
19679
19680 if (!args) SWIG_fail;
19681 swig_obj[0] = args;
19682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19683 if (!SWIG_IsOK(res1)) {
19684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19685 }
19686 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19687 {
19688 PyThreadState* __tstate = wxPyBeginAllowThreads();
19689 result = (arg1)->GetPosition();
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19701 PyObject *resultobj = 0;
19702 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19703 bool result;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 PyObject *swig_obj[1] ;
19707
19708 if (!args) SWIG_fail;
19709 swig_obj[0] = args;
19710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19711 if (!SWIG_IsOK(res1)) {
19712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19713 }
19714 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (bool)(arg1)->ControlDown();
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 {
19722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19723 }
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19731 PyObject *resultobj = 0;
19732 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19733 bool result;
19734 void *argp1 = 0 ;
19735 int res1 = 0 ;
19736 PyObject *swig_obj[1] ;
19737
19738 if (!args) SWIG_fail;
19739 swig_obj[0] = args;
19740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19741 if (!SWIG_IsOK(res1)) {
19742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19743 }
19744 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 result = (bool)(arg1)->MetaDown();
19748 wxPyEndAllowThreads(__tstate);
19749 if (PyErr_Occurred()) SWIG_fail;
19750 }
19751 {
19752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19753 }
19754 return resultobj;
19755 fail:
19756 return NULL;
19757 }
19758
19759
19760 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19761 PyObject *resultobj = 0;
19762 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19763 bool result;
19764 void *argp1 = 0 ;
19765 int res1 = 0 ;
19766 PyObject *swig_obj[1] ;
19767
19768 if (!args) SWIG_fail;
19769 swig_obj[0] = args;
19770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19771 if (!SWIG_IsOK(res1)) {
19772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19773 }
19774 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19775 {
19776 PyThreadState* __tstate = wxPyBeginAllowThreads();
19777 result = (bool)(arg1)->ShiftDown();
19778 wxPyEndAllowThreads(__tstate);
19779 if (PyErr_Occurred()) SWIG_fail;
19780 }
19781 {
19782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19783 }
19784 return resultobj;
19785 fail:
19786 return NULL;
19787 }
19788
19789
19790 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19791 PyObject *resultobj = 0;
19792 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19793 bool result;
19794 void *argp1 = 0 ;
19795 int res1 = 0 ;
19796 PyObject *swig_obj[1] ;
19797
19798 if (!args) SWIG_fail;
19799 swig_obj[0] = args;
19800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19801 if (!SWIG_IsOK(res1)) {
19802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19803 }
19804 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19805 {
19806 PyThreadState* __tstate = wxPyBeginAllowThreads();
19807 result = (bool)(arg1)->AltDown();
19808 wxPyEndAllowThreads(__tstate);
19809 if (PyErr_Occurred()) SWIG_fail;
19810 }
19811 {
19812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19813 }
19814 return resultobj;
19815 fail:
19816 return NULL;
19817 }
19818
19819
19820 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19821 PyObject *resultobj = 0;
19822 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19823 bool result;
19824 void *argp1 = 0 ;
19825 int res1 = 0 ;
19826 PyObject *swig_obj[1] ;
19827
19828 if (!args) SWIG_fail;
19829 swig_obj[0] = args;
19830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19831 if (!SWIG_IsOK(res1)) {
19832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19833 }
19834 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 result = (bool)(arg1)->CmdDown();
19838 wxPyEndAllowThreads(__tstate);
19839 if (PyErr_Occurred()) SWIG_fail;
19840 }
19841 {
19842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19843 }
19844 return resultobj;
19845 fail:
19846 return NULL;
19847 }
19848
19849
19850 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19851 PyObject *obj;
19852 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19853 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19854 return SWIG_Py_Void();
19855 }
19856
19857 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19858 return SWIG_Python_InitShadowInstance(args);
19859 }
19860
19861 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19862 PyObject *resultobj = 0;
19863 int arg1 ;
19864 wxEventType arg2 ;
19865 wxGrid *arg3 = (wxGrid *) 0 ;
19866 wxGridCellCoords *arg4 = 0 ;
19867 wxGridCellCoords *arg5 = 0 ;
19868 bool arg6 = (bool) true ;
19869 bool arg7 = (bool) false ;
19870 bool arg8 = (bool) false ;
19871 bool arg9 = (bool) false ;
19872 bool arg10 = (bool) false ;
19873 wxGridRangeSelectEvent *result = 0 ;
19874 int val1 ;
19875 int ecode1 = 0 ;
19876 int val2 ;
19877 int ecode2 = 0 ;
19878 void *argp3 = 0 ;
19879 int res3 = 0 ;
19880 wxGridCellCoords temp4 ;
19881 wxGridCellCoords temp5 ;
19882 bool val6 ;
19883 int ecode6 = 0 ;
19884 bool val7 ;
19885 int ecode7 = 0 ;
19886 bool val8 ;
19887 int ecode8 = 0 ;
19888 bool val9 ;
19889 int ecode9 = 0 ;
19890 bool val10 ;
19891 int ecode10 = 0 ;
19892 PyObject * obj0 = 0 ;
19893 PyObject * obj1 = 0 ;
19894 PyObject * obj2 = 0 ;
19895 PyObject * obj3 = 0 ;
19896 PyObject * obj4 = 0 ;
19897 PyObject * obj5 = 0 ;
19898 PyObject * obj6 = 0 ;
19899 PyObject * obj7 = 0 ;
19900 PyObject * obj8 = 0 ;
19901 PyObject * obj9 = 0 ;
19902 char * kwnames[] = {
19903 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19904 };
19905
19906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19907 ecode1 = SWIG_AsVal_int(obj0, &val1);
19908 if (!SWIG_IsOK(ecode1)) {
19909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19910 }
19911 arg1 = static_cast< int >(val1);
19912 ecode2 = SWIG_AsVal_int(obj1, &val2);
19913 if (!SWIG_IsOK(ecode2)) {
19914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19915 }
19916 arg2 = static_cast< wxEventType >(val2);
19917 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19918 if (!SWIG_IsOK(res3)) {
19919 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19920 }
19921 arg3 = reinterpret_cast< wxGrid * >(argp3);
19922 {
19923 arg4 = &temp4;
19924 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19925 }
19926 {
19927 arg5 = &temp5;
19928 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19929 }
19930 if (obj5) {
19931 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19932 if (!SWIG_IsOK(ecode6)) {
19933 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19934 }
19935 arg6 = static_cast< bool >(val6);
19936 }
19937 if (obj6) {
19938 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19939 if (!SWIG_IsOK(ecode7)) {
19940 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19941 }
19942 arg7 = static_cast< bool >(val7);
19943 }
19944 if (obj7) {
19945 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19946 if (!SWIG_IsOK(ecode8)) {
19947 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19948 }
19949 arg8 = static_cast< bool >(val8);
19950 }
19951 if (obj8) {
19952 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19953 if (!SWIG_IsOK(ecode9)) {
19954 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19955 }
19956 arg9 = static_cast< bool >(val9);
19957 }
19958 if (obj9) {
19959 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19960 if (!SWIG_IsOK(ecode10)) {
19961 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19962 }
19963 arg10 = static_cast< bool >(val10);
19964 }
19965 {
19966 PyThreadState* __tstate = wxPyBeginAllowThreads();
19967 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19968 wxPyEndAllowThreads(__tstate);
19969 if (PyErr_Occurred()) SWIG_fail;
19970 }
19971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19972 return resultobj;
19973 fail:
19974 return NULL;
19975 }
19976
19977
19978 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19979 PyObject *resultobj = 0;
19980 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19981 wxGridCellCoords result;
19982 void *argp1 = 0 ;
19983 int res1 = 0 ;
19984 PyObject *swig_obj[1] ;
19985
19986 if (!args) SWIG_fail;
19987 swig_obj[0] = args;
19988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19989 if (!SWIG_IsOK(res1)) {
19990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19991 }
19992 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19993 {
19994 PyThreadState* __tstate = wxPyBeginAllowThreads();
19995 result = (arg1)->GetTopLeftCoords();
19996 wxPyEndAllowThreads(__tstate);
19997 if (PyErr_Occurred()) SWIG_fail;
19998 }
19999 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20000 return resultobj;
20001 fail:
20002 return NULL;
20003 }
20004
20005
20006 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20007 PyObject *resultobj = 0;
20008 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20009 wxGridCellCoords result;
20010 void *argp1 = 0 ;
20011 int res1 = 0 ;
20012 PyObject *swig_obj[1] ;
20013
20014 if (!args) SWIG_fail;
20015 swig_obj[0] = args;
20016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20017 if (!SWIG_IsOK(res1)) {
20018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20019 }
20020 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20021 {
20022 PyThreadState* __tstate = wxPyBeginAllowThreads();
20023 result = (arg1)->GetBottomRightCoords();
20024 wxPyEndAllowThreads(__tstate);
20025 if (PyErr_Occurred()) SWIG_fail;
20026 }
20027 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
20028 return resultobj;
20029 fail:
20030 return NULL;
20031 }
20032
20033
20034 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20035 PyObject *resultobj = 0;
20036 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20037 int result;
20038 void *argp1 = 0 ;
20039 int res1 = 0 ;
20040 PyObject *swig_obj[1] ;
20041
20042 if (!args) SWIG_fail;
20043 swig_obj[0] = args;
20044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20045 if (!SWIG_IsOK(res1)) {
20046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20047 }
20048 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 result = (int)(arg1)->GetTopRow();
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 resultobj = SWIG_From_int(static_cast< int >(result));
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20063 PyObject *resultobj = 0;
20064 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20065 int result;
20066 void *argp1 = 0 ;
20067 int res1 = 0 ;
20068 PyObject *swig_obj[1] ;
20069
20070 if (!args) SWIG_fail;
20071 swig_obj[0] = args;
20072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20073 if (!SWIG_IsOK(res1)) {
20074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20075 }
20076 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 result = (int)(arg1)->GetBottomRow();
20080 wxPyEndAllowThreads(__tstate);
20081 if (PyErr_Occurred()) SWIG_fail;
20082 }
20083 resultobj = SWIG_From_int(static_cast< int >(result));
20084 return resultobj;
20085 fail:
20086 return NULL;
20087 }
20088
20089
20090 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20091 PyObject *resultobj = 0;
20092 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20093 int result;
20094 void *argp1 = 0 ;
20095 int res1 = 0 ;
20096 PyObject *swig_obj[1] ;
20097
20098 if (!args) SWIG_fail;
20099 swig_obj[0] = args;
20100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20101 if (!SWIG_IsOK(res1)) {
20102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20103 }
20104 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 result = (int)(arg1)->GetLeftCol();
20108 wxPyEndAllowThreads(__tstate);
20109 if (PyErr_Occurred()) SWIG_fail;
20110 }
20111 resultobj = SWIG_From_int(static_cast< int >(result));
20112 return resultobj;
20113 fail:
20114 return NULL;
20115 }
20116
20117
20118 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20119 PyObject *resultobj = 0;
20120 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20121 int result;
20122 void *argp1 = 0 ;
20123 int res1 = 0 ;
20124 PyObject *swig_obj[1] ;
20125
20126 if (!args) SWIG_fail;
20127 swig_obj[0] = args;
20128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20129 if (!SWIG_IsOK(res1)) {
20130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20131 }
20132 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 result = (int)(arg1)->GetRightCol();
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 resultobj = SWIG_From_int(static_cast< int >(result));
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *resultobj = 0;
20148 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20149 bool result;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 PyObject *swig_obj[1] ;
20153
20154 if (!args) SWIG_fail;
20155 swig_obj[0] = args;
20156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20157 if (!SWIG_IsOK(res1)) {
20158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20159 }
20160 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (bool)(arg1)->Selecting();
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 {
20168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20169 }
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20177 PyObject *resultobj = 0;
20178 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20179 bool 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_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20189 }
20190 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (bool)(arg1)->ControlDown();
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 {
20198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20199 }
20200 return resultobj;
20201 fail:
20202 return NULL;
20203 }
20204
20205
20206 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20207 PyObject *resultobj = 0;
20208 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20209 bool result;
20210 void *argp1 = 0 ;
20211 int res1 = 0 ;
20212 PyObject *swig_obj[1] ;
20213
20214 if (!args) SWIG_fail;
20215 swig_obj[0] = args;
20216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20217 if (!SWIG_IsOK(res1)) {
20218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20219 }
20220 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 result = (bool)(arg1)->MetaDown();
20224 wxPyEndAllowThreads(__tstate);
20225 if (PyErr_Occurred()) SWIG_fail;
20226 }
20227 {
20228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20229 }
20230 return resultobj;
20231 fail:
20232 return NULL;
20233 }
20234
20235
20236 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20237 PyObject *resultobj = 0;
20238 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20239 bool result;
20240 void *argp1 = 0 ;
20241 int res1 = 0 ;
20242 PyObject *swig_obj[1] ;
20243
20244 if (!args) SWIG_fail;
20245 swig_obj[0] = args;
20246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20247 if (!SWIG_IsOK(res1)) {
20248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20249 }
20250 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20251 {
20252 PyThreadState* __tstate = wxPyBeginAllowThreads();
20253 result = (bool)(arg1)->ShiftDown();
20254 wxPyEndAllowThreads(__tstate);
20255 if (PyErr_Occurred()) SWIG_fail;
20256 }
20257 {
20258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20259 }
20260 return resultobj;
20261 fail:
20262 return NULL;
20263 }
20264
20265
20266 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20267 PyObject *resultobj = 0;
20268 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20269 bool result;
20270 void *argp1 = 0 ;
20271 int res1 = 0 ;
20272 PyObject *swig_obj[1] ;
20273
20274 if (!args) SWIG_fail;
20275 swig_obj[0] = args;
20276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20277 if (!SWIG_IsOK(res1)) {
20278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20279 }
20280 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20281 {
20282 PyThreadState* __tstate = wxPyBeginAllowThreads();
20283 result = (bool)(arg1)->AltDown();
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 {
20288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20289 }
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20297 PyObject *resultobj = 0;
20298 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
20299 bool result;
20300 void *argp1 = 0 ;
20301 int res1 = 0 ;
20302 PyObject *swig_obj[1] ;
20303
20304 if (!args) SWIG_fail;
20305 swig_obj[0] = args;
20306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
20307 if (!SWIG_IsOK(res1)) {
20308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
20309 }
20310 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
20311 {
20312 PyThreadState* __tstate = wxPyBeginAllowThreads();
20313 result = (bool)(arg1)->CmdDown();
20314 wxPyEndAllowThreads(__tstate);
20315 if (PyErr_Occurred()) SWIG_fail;
20316 }
20317 {
20318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20319 }
20320 return resultobj;
20321 fail:
20322 return NULL;
20323 }
20324
20325
20326 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20327 PyObject *obj;
20328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20329 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
20330 return SWIG_Py_Void();
20331 }
20332
20333 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20334 return SWIG_Python_InitShadowInstance(args);
20335 }
20336
20337 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20338 PyObject *resultobj = 0;
20339 int arg1 ;
20340 wxEventType arg2 ;
20341 wxObject *arg3 = (wxObject *) 0 ;
20342 int arg4 ;
20343 int arg5 ;
20344 wxControl *arg6 = (wxControl *) 0 ;
20345 wxGridEditorCreatedEvent *result = 0 ;
20346 int val1 ;
20347 int ecode1 = 0 ;
20348 int val2 ;
20349 int ecode2 = 0 ;
20350 void *argp3 = 0 ;
20351 int res3 = 0 ;
20352 int val4 ;
20353 int ecode4 = 0 ;
20354 int val5 ;
20355 int ecode5 = 0 ;
20356 void *argp6 = 0 ;
20357 int res6 = 0 ;
20358 PyObject * obj0 = 0 ;
20359 PyObject * obj1 = 0 ;
20360 PyObject * obj2 = 0 ;
20361 PyObject * obj3 = 0 ;
20362 PyObject * obj4 = 0 ;
20363 PyObject * obj5 = 0 ;
20364 char * kwnames[] = {
20365 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
20366 };
20367
20368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20369 ecode1 = SWIG_AsVal_int(obj0, &val1);
20370 if (!SWIG_IsOK(ecode1)) {
20371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
20372 }
20373 arg1 = static_cast< int >(val1);
20374 ecode2 = SWIG_AsVal_int(obj1, &val2);
20375 if (!SWIG_IsOK(ecode2)) {
20376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
20377 }
20378 arg2 = static_cast< wxEventType >(val2);
20379 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
20380 if (!SWIG_IsOK(res3)) {
20381 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
20382 }
20383 arg3 = reinterpret_cast< wxObject * >(argp3);
20384 ecode4 = SWIG_AsVal_int(obj3, &val4);
20385 if (!SWIG_IsOK(ecode4)) {
20386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
20387 }
20388 arg4 = static_cast< int >(val4);
20389 ecode5 = SWIG_AsVal_int(obj4, &val5);
20390 if (!SWIG_IsOK(ecode5)) {
20391 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
20392 }
20393 arg5 = static_cast< int >(val5);
20394 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
20395 if (!SWIG_IsOK(res6)) {
20396 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
20397 }
20398 arg6 = reinterpret_cast< wxControl * >(argp6);
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
20406 return resultobj;
20407 fail:
20408 return NULL;
20409 }
20410
20411
20412 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20413 PyObject *resultobj = 0;
20414 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20415 int result;
20416 void *argp1 = 0 ;
20417 int res1 = 0 ;
20418 PyObject *swig_obj[1] ;
20419
20420 if (!args) SWIG_fail;
20421 swig_obj[0] = args;
20422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20423 if (!SWIG_IsOK(res1)) {
20424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20425 }
20426 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20427 {
20428 PyThreadState* __tstate = wxPyBeginAllowThreads();
20429 result = (int)(arg1)->GetRow();
20430 wxPyEndAllowThreads(__tstate);
20431 if (PyErr_Occurred()) SWIG_fail;
20432 }
20433 resultobj = SWIG_From_int(static_cast< int >(result));
20434 return resultobj;
20435 fail:
20436 return NULL;
20437 }
20438
20439
20440 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20441 PyObject *resultobj = 0;
20442 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20443 int result;
20444 void *argp1 = 0 ;
20445 int res1 = 0 ;
20446 PyObject *swig_obj[1] ;
20447
20448 if (!args) SWIG_fail;
20449 swig_obj[0] = args;
20450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20451 if (!SWIG_IsOK(res1)) {
20452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20453 }
20454 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = (int)(arg1)->GetCol();
20458 wxPyEndAllowThreads(__tstate);
20459 if (PyErr_Occurred()) SWIG_fail;
20460 }
20461 resultobj = SWIG_From_int(static_cast< int >(result));
20462 return resultobj;
20463 fail:
20464 return NULL;
20465 }
20466
20467
20468 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20469 PyObject *resultobj = 0;
20470 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20471 wxControl *result = 0 ;
20472 void *argp1 = 0 ;
20473 int res1 = 0 ;
20474 PyObject *swig_obj[1] ;
20475
20476 if (!args) SWIG_fail;
20477 swig_obj[0] = args;
20478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20479 if (!SWIG_IsOK(res1)) {
20480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20481 }
20482 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 result = (wxControl *)(arg1)->GetControl();
20486 wxPyEndAllowThreads(__tstate);
20487 if (PyErr_Occurred()) SWIG_fail;
20488 }
20489 {
20490 resultobj = wxPyMake_wxObject(result, 0);
20491 }
20492 return resultobj;
20493 fail:
20494 return NULL;
20495 }
20496
20497
20498 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20499 PyObject *resultobj = 0;
20500 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20501 int arg2 ;
20502 void *argp1 = 0 ;
20503 int res1 = 0 ;
20504 int val2 ;
20505 int ecode2 = 0 ;
20506 PyObject * obj0 = 0 ;
20507 PyObject * obj1 = 0 ;
20508 char * kwnames[] = {
20509 (char *) "self",(char *) "row", NULL
20510 };
20511
20512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
20513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20514 if (!SWIG_IsOK(res1)) {
20515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20516 }
20517 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20518 ecode2 = SWIG_AsVal_int(obj1, &val2);
20519 if (!SWIG_IsOK(ecode2)) {
20520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
20521 }
20522 arg2 = static_cast< int >(val2);
20523 {
20524 PyThreadState* __tstate = wxPyBeginAllowThreads();
20525 (arg1)->SetRow(arg2);
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 resultobj = SWIG_Py_Void();
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20537 PyObject *resultobj = 0;
20538 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20539 int arg2 ;
20540 void *argp1 = 0 ;
20541 int res1 = 0 ;
20542 int val2 ;
20543 int ecode2 = 0 ;
20544 PyObject * obj0 = 0 ;
20545 PyObject * obj1 = 0 ;
20546 char * kwnames[] = {
20547 (char *) "self",(char *) "col", NULL
20548 };
20549
20550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
20551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20552 if (!SWIG_IsOK(res1)) {
20553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20554 }
20555 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20556 ecode2 = SWIG_AsVal_int(obj1, &val2);
20557 if (!SWIG_IsOK(ecode2)) {
20558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
20559 }
20560 arg2 = static_cast< int >(val2);
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 (arg1)->SetCol(arg2);
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 resultobj = SWIG_Py_Void();
20568 return resultobj;
20569 fail:
20570 return NULL;
20571 }
20572
20573
20574 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20575 PyObject *resultobj = 0;
20576 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
20577 wxControl *arg2 = (wxControl *) 0 ;
20578 void *argp1 = 0 ;
20579 int res1 = 0 ;
20580 void *argp2 = 0 ;
20581 int res2 = 0 ;
20582 PyObject * obj0 = 0 ;
20583 PyObject * obj1 = 0 ;
20584 char * kwnames[] = {
20585 (char *) "self",(char *) "ctrl", NULL
20586 };
20587
20588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
20589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
20590 if (!SWIG_IsOK(res1)) {
20591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
20592 }
20593 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
20594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
20595 if (!SWIG_IsOK(res2)) {
20596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
20597 }
20598 arg2 = reinterpret_cast< wxControl * >(argp2);
20599 {
20600 PyThreadState* __tstate = wxPyBeginAllowThreads();
20601 (arg1)->SetControl(arg2);
20602 wxPyEndAllowThreads(__tstate);
20603 if (PyErr_Occurred()) SWIG_fail;
20604 }
20605 resultobj = SWIG_Py_Void();
20606 return resultobj;
20607 fail:
20608 return NULL;
20609 }
20610
20611
20612 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20613 PyObject *obj;
20614 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20615 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20616 return SWIG_Py_Void();
20617 }
20618
20619 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20620 return SWIG_Python_InitShadowInstance(args);
20621 }
20622
20623 static PyMethodDef SwigMethods[] = {
20624 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20626 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20628 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20629 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20630 { (char *)"GridCellRenderer_Draw", (PyCFunction) _wrap_GridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"GridCellRenderer_GetBestSize", (PyCFunction) _wrap_GridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"GridCellRenderer_Clone", (PyCFunction)_wrap_GridCellRenderer_Clone, METH_O, NULL},
20633 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20634 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20635 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20638 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20639 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20640 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20641 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20642 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20643 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20644 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20645 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20647 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20649 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20651 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20652 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20653 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20654 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20655 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20657 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20658 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20660 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20661 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20662 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20663 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20664 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20665 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20666 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20668 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20673 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20674 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20680 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20682 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20683 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20684 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20687 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20688 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20689 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20690 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20691 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20692 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20694 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20695 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20697 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20698 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20699 { (char *)"GridCellBoolEditor_UseStringValues", (PyCFunction) _wrap_GridCellBoolEditor_UseStringValues, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"GridCellBoolEditor_IsTrueValue", (PyCFunction) _wrap_GridCellBoolEditor_IsTrueValue, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20702 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20703 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20705 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20706 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20708 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20709 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20710 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20711 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20712 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20715 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20716 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20718 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20719 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20730 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20731 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20732 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20733 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20734 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20735 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20736 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20737 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20738 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20739 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20740 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20741 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20742 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20743 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20746 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20747 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20749 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20750 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20751 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20759 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20760 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20761 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20767 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20768 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20769 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20772 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20774 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20775 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20776 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20789 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20800 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20805 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20806 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20808 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20809 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20810 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20812 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20813 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20815 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20817 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20819 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20821 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20823 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20824 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20825 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20827 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20828 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20830 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20835 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20836 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20837 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20839 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20843 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20844 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20845 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20847 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20849 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20859 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20860 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20861 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20862 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20863 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20866 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20867 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20868 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20869 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20870 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20871 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20872 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20873 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20880 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20881 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20889 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20890 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20895 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20896 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20897 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20898 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20899 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20900 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20901 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20902 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20903 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20904 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20907 { (char *)"Grid_GetDefaultGridLinePen", (PyCFunction)_wrap_Grid_GetDefaultGridLinePen, METH_O, NULL},
20908 { (char *)"Grid_GetRowGridLinePen", (PyCFunction) _wrap_Grid_GetRowGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"Grid_GetColGridLinePen", (PyCFunction) _wrap_Grid_GetColGridLinePen, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20911 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20912 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20913 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20929 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20930 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20932 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20933 { (char *)"Grid_EnableDragColMove", (PyCFunction) _wrap_Grid_EnableDragColMove, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"Grid_DisableDragColMove", (PyCFunction)_wrap_Grid_DisableDragColMove, METH_O, NULL},
20935 { (char *)"Grid_CanDragColMove", (PyCFunction)_wrap_Grid_CanDragColMove, METH_O, NULL},
20936 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20938 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20939 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20941 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20942 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20952 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20953 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20955 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20957 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20959 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20961 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20963 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20965 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"Grid_GetColAt", (PyCFunction) _wrap_Grid_GetColAt, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"Grid_SetColPos", (PyCFunction) _wrap_Grid_SetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"Grid_GetColPos", (PyCFunction) _wrap_Grid_GetColPos, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20979 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20986 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20987 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
21001 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
21005 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
21014 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
21015 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
21016 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
21018 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
21019 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
21020 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
21021 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
21022 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
21027 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
21028 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
21037 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
21038 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
21039 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
21040 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
21042 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
21043 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
21044 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
21047 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
21048 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
21049 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21050 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
21051 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
21052 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
21053 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
21054 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
21055 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
21056 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
21057 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
21058 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
21059 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
21060 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
21061 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
21063 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
21064 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
21065 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
21066 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
21067 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
21068 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
21069 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
21070 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
21071 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
21073 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
21074 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
21075 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
21076 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
21077 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
21078 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
21079 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
21080 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
21081 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
21082 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
21083 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
21084 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
21085 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
21086 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
21088 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
21089 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
21090 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
21094 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
21095 { NULL, NULL, 0, NULL }
21096 };
21097
21098
21099 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21100
21101 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
21102 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21103 }
21104 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
21105 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21106 }
21107 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
21108 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21109 }
21110 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
21111 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21112 }
21113 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
21114 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21115 }
21116 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
21117 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21118 }
21119 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
21120 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21121 }
21122 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
21123 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21124 }
21125 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
21126 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21127 }
21128 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
21129 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21130 }
21131 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
21132 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21133 }
21134 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
21135 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21136 }
21137 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
21138 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21139 }
21140 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
21141 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21142 }
21143 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
21144 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21145 }
21146 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
21147 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21148 }
21149 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
21150 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21151 }
21152 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
21153 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21154 }
21155 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
21156 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21157 }
21158 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
21159 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21160 }
21161 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
21162 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
21163 }
21164 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
21165 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21166 }
21167 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
21168 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
21169 }
21170 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
21171 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
21172 }
21173 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
21174 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
21175 }
21176 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
21177 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
21178 }
21179 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
21180 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
21181 }
21182 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
21183 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
21184 }
21185 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
21186 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
21187 }
21188 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
21189 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
21190 }
21191 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
21192 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
21193 }
21194 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
21195 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
21196 }
21197 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
21198 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
21199 }
21200 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
21201 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21202 }
21203 static void *_p_wxGridTo_p_wxPanel(void *x) {
21204 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
21205 }
21206 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
21207 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21208 }
21209 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
21210 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21211 }
21212 static void *_p_wxSimpleHtmlListBoxTo_p_wxPanel(void *x) {
21213 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21214 }
21215 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
21216 return (void *)((wxPanel *) ((wxPyPanel *) x));
21217 }
21218 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
21219 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
21220 }
21221 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
21222 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
21223 }
21224 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
21225 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21226 }
21227 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
21228 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
21229 }
21230 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
21231 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21232 }
21233 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
21234 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
21235 }
21236 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
21237 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
21238 }
21239 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
21240 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21241 }
21242 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
21243 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
21244 }
21245 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
21246 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
21247 }
21248 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
21249 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21250 }
21251 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
21252 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21253 }
21254 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
21255 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
21256 }
21257 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21258 return (void *)((wxWindow *) ((wxMenuBar *) x));
21259 }
21260 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
21261 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21262 }
21263 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
21264 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21265 }
21266 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
21267 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21268 }
21269 static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {
21270 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21271 }
21272 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
21273 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21274 }
21275 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
21276 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21277 }
21278 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
21279 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21280 }
21281 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
21282 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21283 }
21284 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
21285 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21286 }
21287 static void *_p_wxPanelTo_p_wxWindow(void *x) {
21288 return (void *)((wxWindow *) ((wxPanel *) x));
21289 }
21290 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
21291 return (void *)((wxWindow *) ((wxStatusBar *) x));
21292 }
21293 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
21294 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
21295 }
21296 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
21297 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21298 }
21299 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
21300 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21301 }
21302 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
21303 return (void *)((wxWindow *) ((wxPopupWindow *) x));
21304 }
21305 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
21306 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
21307 }
21308 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
21309 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
21310 }
21311 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
21312 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
21313 }
21314 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
21315 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
21316 }
21317 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
21318 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
21319 }
21320 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
21321 return (void *)((wxWindow *) ((wxSashWindow *) x));
21322 }
21323 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
21324 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
21325 }
21326 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
21327 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21328 }
21329 static void *_p_wxControlTo_p_wxWindow(void *x) {
21330 return (void *)((wxWindow *) ((wxControl *) x));
21331 }
21332 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
21333 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21334 }
21335 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
21336 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21337 }
21338 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
21339 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21340 }
21341 static void *_p_wxGridTo_p_wxWindow(void *x) {
21342 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21343 }
21344 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21345 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21346 }
21347 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
21348 return (void *)((wxWindow *) ((wxPyWindow *) x));
21349 }
21350 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
21351 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21352 }
21353 static void *_p_wxSimpleHtmlListBoxTo_p_wxWindow(void *x) {
21354 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21355 }
21356 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
21357 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21358 }
21359 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
21360 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21361 }
21362 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
21363 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
21364 }
21365 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
21366 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21367 }
21368 static void *_p_wxFrameTo_p_wxWindow(void *x) {
21369 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
21370 }
21371 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
21372 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21373 }
21374 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
21375 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21376 }
21377 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
21378 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21379 }
21380 static void *_p_wxDialogTo_p_wxWindow(void *x) {
21381 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
21382 }
21383 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
21384 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21385 }
21386 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
21387 return (void *)((wxControl *) ((wxControlWithItems *) x));
21388 }
21389 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
21390 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
21391 }
21392 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
21393 return (void *)((wxEvent *) ((wxMenuEvent *) x));
21394 }
21395 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
21396 return (void *)((wxEvent *) ((wxCloseEvent *) x));
21397 }
21398 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
21399 return (void *)((wxEvent *) ((wxMouseEvent *) x));
21400 }
21401 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
21402 return (void *)((wxEvent *) ((wxEraseEvent *) x));
21403 }
21404 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
21405 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
21406 }
21407 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
21408 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21409 }
21410 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
21411 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
21412 }
21413 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
21414 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
21415 }
21416 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
21417 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
21418 }
21419 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
21420 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
21421 }
21422 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
21423 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
21424 }
21425 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
21426 return (void *)((wxEvent *) ((wxPyEvent *) x));
21427 }
21428 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
21429 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
21430 }
21431 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
21432 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21433 }
21434 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
21435 return (void *)((wxEvent *) ((wxIdleEvent *) x));
21436 }
21437 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
21438 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
21439 }
21440 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
21441 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
21442 }
21443 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
21444 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
21445 }
21446 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
21447 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
21448 }
21449 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
21450 return (void *)((wxEvent *) ((wxActivateEvent *) x));
21451 }
21452 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
21453 return (void *)((wxEvent *) ((wxSizeEvent *) x));
21454 }
21455 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
21456 return (void *)((wxEvent *) ((wxMoveEvent *) x));
21457 }
21458 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
21459 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
21460 }
21461 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
21462 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21463 }
21464 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
21465 return (void *)((wxEvent *) ((wxPaintEvent *) x));
21466 }
21467 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
21468 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
21469 }
21470 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
21471 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
21472 }
21473 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
21474 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
21475 }
21476 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
21477 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
21478 }
21479 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
21480 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
21481 }
21482 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
21483 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21484 }
21485 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
21486 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
21487 }
21488 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
21489 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21490 }
21491 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
21492 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21493 }
21494 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
21495 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
21496 }
21497 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
21498 return (void *)((wxEvent *) ((wxFocusEvent *) x));
21499 }
21500 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
21501 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
21502 }
21503 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
21504 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
21505 }
21506 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
21507 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21508 }
21509 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
21510 return (void *)((wxEvent *) ((wxShowEvent *) x));
21511 }
21512 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
21513 return (void *)((wxEvent *) ((wxCommandEvent *) x));
21514 }
21515 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
21516 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
21517 }
21518 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
21519 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21520 }
21521 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
21522 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
21523 }
21524 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
21525 return (void *)((wxEvent *) ((wxKeyEvent *) x));
21526 }
21527 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
21528 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
21529 }
21530 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
21531 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
21532 }
21533 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21534 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21535 }
21536 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
21537 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
21538 }
21539 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
21540 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21541 }
21542 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
21543 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21544 }
21545 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21546 return (void *)((wxObject *) ((wxSizerItem *) x));
21547 }
21548 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21549 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21550 }
21551 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21552 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21553 }
21554 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21555 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21556 }
21557 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21558 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21559 }
21560 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21561 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21562 }
21563 static void *_p_wxSizerTo_p_wxObject(void *x) {
21564 return (void *)((wxObject *) ((wxSizer *) x));
21565 }
21566 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21567 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21568 }
21569 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21570 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21571 }
21572 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
21573 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21574 }
21575 static void *_p_wxEventTo_p_wxObject(void *x) {
21576 return (void *)((wxObject *) ((wxEvent *) x));
21577 }
21578 static void *_p_wxFontDataTo_p_wxObject(void *x) {
21579 return (void *)((wxObject *) ((wxFontData *) x));
21580 }
21581 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
21582 return (void *)((wxObject *) ((wxPrintData *) x));
21583 }
21584 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21585 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21586 }
21587 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21588 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21589 }
21590 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21591 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21592 }
21593 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
21594 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
21595 }
21596 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
21597 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21598 }
21599 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
21600 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
21601 }
21602 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
21603 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
21604 }
21605 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
21606 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
21607 }
21608 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21609 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21610 }
21611 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21612 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21613 }
21614 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21615 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21616 }
21617 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21618 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21619 }
21620 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21621 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21622 }
21623 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21624 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21625 }
21626 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21627 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21628 }
21629 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21630 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21631 }
21632 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21633 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21634 }
21635 static void *_p_wxControlTo_p_wxObject(void *x) {
21636 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21637 }
21638 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21639 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21640 }
21641 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21643 }
21644 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21645 return (void *)((wxObject *) ((wxFSFile *) x));
21646 }
21647 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21648 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21649 }
21650 static void *_p_wxGridTo_p_wxObject(void *x) {
21651 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21652 }
21653 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21654 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21655 }
21656 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21657 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21658 }
21659 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21660 return (void *)((wxObject *) ((wxColourData *) x));
21661 }
21662 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21663 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21664 }
21665 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21666 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21667 }
21668 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21669 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21670 }
21671 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21672 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21673 }
21674 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21675 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21676 }
21677 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21678 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21679 }
21680 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21681 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21682 }
21683 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21684 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21685 }
21686 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21687 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21688 }
21689 static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {
21690 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
21691 }
21692 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21693 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21694 }
21695 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21696 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21697 }
21698 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21699 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21700 }
21701 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21702 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21703 }
21704 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21705 return (void *)((wxObject *) ((wxPrinter *) x));
21706 }
21707 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21708 return (void *)((wxObject *) ((wxMenuItem *) x));
21709 }
21710 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21711 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21712 }
21713 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21714 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21715 }
21716 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21717 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21718 }
21719 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21720 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21721 }
21722 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21723 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21724 }
21725 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21726 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21727 }
21728 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21729 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21730 }
21731 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21732 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21733 }
21734 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21735 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21736 }
21737 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21738 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21739 }
21740 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21741 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21742 }
21743 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21744 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21745 }
21746 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21747 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21748 }
21749 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21750 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21751 }
21752 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21753 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21754 }
21755 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21756 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21757 }
21758 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21759 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21760 }
21761 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21762 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21763 }
21764 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21765 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21766 }
21767 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21768 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21769 }
21770 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21771 return (void *)((wxObject *) ((wxImageHandler *) x));
21772 }
21773 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21774 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21775 }
21776 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21777 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21778 }
21779 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
21780 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
21781 }
21782 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21783 return (void *)((wxObject *) ((wxEvtHandler *) x));
21784 }
21785 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
21786 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
21787 }
21788 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21789 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21790 }
21791 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21792 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21793 }
21794 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21795 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21796 }
21797 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21798 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21799 }
21800 static void *_p_wxSimpleHtmlListBoxTo_p_wxObject(void *x) {
21801 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
21802 }
21803 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21804 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21805 }
21806 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21807 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21808 }
21809 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21810 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21811 }
21812 static void *_p_wxImageTo_p_wxObject(void *x) {
21813 return (void *)((wxObject *) ((wxImage *) x));
21814 }
21815 static void *_p_wxFrameTo_p_wxObject(void *x) {
21816 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21817 }
21818 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21819 return (void *)((wxObject *) ((wxPyPrintout *) x));
21820 }
21821 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21822 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21823 }
21824 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21825 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21826 }
21827 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21828 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21829 }
21830 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21831 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21832 }
21833 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21834 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21835 }
21836 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21837 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21838 }
21839 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21840 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21841 }
21842 static void *_p_wxWindowTo_p_wxObject(void *x) {
21843 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21844 }
21845 static void *_p_wxMenuTo_p_wxObject(void *x) {
21846 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21847 }
21848 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21849 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21850 }
21851 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21852 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21853 }
21854 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21855 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21856 }
21857 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21858 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21859 }
21860 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21861 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21862 }
21863 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21864 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21865 }
21866 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21867 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21868 }
21869 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21870 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21871 }
21872 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21873 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21874 }
21875 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21876 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
21877 }
21878 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21879 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21880 }
21881 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21882 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21883 }
21884 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21885 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21886 }
21887 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21888 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21889 }
21890 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21891 return (void *)((wxObject *) ((wxPrintPreview *) x));
21892 }
21893 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21894 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21895 }
21896 static void *_p_wxPanelTo_p_wxObject(void *x) {
21897 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21898 }
21899 static void *_p_wxDialogTo_p_wxObject(void *x) {
21900 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21901 }
21902 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21903 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21904 }
21905 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21906 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21907 }
21908 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21909 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21910 }
21911 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21912 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21913 }
21914 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21915 return (void *)((wxObject *) ((wxPrintDialog *) x));
21916 }
21917 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21918 return (void *)((wxObject *) ((wxFileSystem *) x));
21919 }
21920 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21921 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21922 }
21923 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21924 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21925 }
21926 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21927 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21928 }
21929 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21930 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21931 }
21932 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21933 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21934 }
21935 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21936 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21937 }
21938 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21939 return (void *)((wxObject *) ((wxGridTableBase *) x));
21940 }
21941 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21942 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21943 }
21944 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21945 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21946 }
21947 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21948 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21949 }
21950 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21951 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21952 }
21953 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21954 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21955 }
21956 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21957 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21958 }
21959 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21960 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21961 }
21962 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21963 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21964 }
21965 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21966 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21967 }
21968 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21969 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21970 }
21971 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21972 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21973 }
21974 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21975 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21976 }
21977 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21978 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21979 }
21980 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21981 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21982 }
21983 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21984 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21985 }
21986 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21987 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21988 }
21989 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21990 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21991 }
21992 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21993 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21994 }
21995 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21996 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21997 }
21998 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21999 return (void *)((wxEvtHandler *) ((wxMenu *) x));
22000 }
22001 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
22002 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
22003 }
22004 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
22005 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
22006 }
22007 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
22008 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
22009 }
22010 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
22011 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
22012 }
22013 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
22014 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
22015 }
22016 static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {
22017 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));
22018 }
22019 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
22020 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
22021 }
22022 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
22023 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
22024 }
22025 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
22026 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
22027 }
22028 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
22029 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
22030 }
22031 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
22032 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
22033 }
22034 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
22035 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
22036 }
22037 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
22038 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxTipWindow *) x));
22039 }
22040 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
22041 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
22042 }
22043 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
22044 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
22045 }
22046 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
22047 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
22048 }
22049 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
22050 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
22051 }
22052 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
22053 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
22054 }
22055 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
22056 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
22057 }
22058 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
22059 return (void *)((wxEvtHandler *) ((wxWindow *) x));
22060 }
22061 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
22062 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
22063 }
22064 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
22065 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
22066 }
22067 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
22068 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
22069 }
22070 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
22071 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
22072 }
22073 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
22074 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
22075 }
22076 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
22077 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
22078 }
22079 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
22080 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
22081 }
22082 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
22083 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
22084 }
22085 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
22086 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
22087 }
22088 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
22089 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
22090 }
22091 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
22092 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22093 }
22094 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
22095 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
22096 }
22097 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
22098 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
22099 }
22100 static void *_p_wxSimpleHtmlListBoxTo_p_wxEvtHandler(void *x) {
22101 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));
22102 }
22103 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
22104 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
22105 }
22106 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
22107 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
22108 }
22109 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
22110 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
22111 }
22112 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
22113 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
22114 }
22115 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
22116 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
22117 }
22118 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
22119 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
22120 }
22121 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
22122 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
22123 }
22124 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
22125 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
22126 }
22127 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
22128 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
22129 }
22130 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
22131 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
22132 }
22133 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
22134 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
22135 }
22136 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
22137 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
22138 }
22139 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
22140 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
22141 }
22142 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
22143 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
22144 }
22145 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
22146 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
22147 }
22148 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
22149 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22150 }
22151 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
22152 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22153 }
22154 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
22155 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
22156 }
22157 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
22158 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
22159 }
22160 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
22161 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22162 }
22163 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
22164 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22165 }
22166 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
22167 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
22168 }
22169 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
22170 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
22171 }
22172 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
22173 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
22174 }
22175 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
22176 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
22177 }
22178 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
22179 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22180 }
22181 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
22182 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
22183 }
22184 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
22185 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
22186 }
22187 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
22188 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
22189 }
22190 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
22191 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
22192 }
22193 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
22194 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
22195 }
22196 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
22197 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
22198 }
22199 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
22200 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
22201 }
22202 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
22203 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
22204 }
22205 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
22206 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
22207 }
22208 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
22209 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
22210 }
22211 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
22212 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
22213 }
22214 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
22215 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
22216 }
22217 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
22218 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
22219 }
22220 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
22221 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
22222 }
22223 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
22224 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
22225 }
22226 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
22227 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
22228 }
22229 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
22230 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
22231 }
22232 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22233 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};
22234 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
22235 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
22236 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
22237 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
22238 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
22239 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
22240 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
22241 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
22242 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
22243 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
22244 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
22245 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
22246 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
22247 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
22248 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
22249 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
22250 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
22251 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
22252 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
22253 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
22254 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
22255 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
22256 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
22257 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
22258 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
22259 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
22260 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
22261 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
22262 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
22263 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
22264 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
22265 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
22266 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
22267 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
22268 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
22269 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
22270 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
22271 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
22272 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
22273 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
22274 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
22275 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
22276 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
22277 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
22278 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
22279 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
22280 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
22281 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
22282 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
22283 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
22284 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
22285 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
22286 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
22287 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
22288 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
22289 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
22290 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
22291 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
22292 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
22293 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
22294 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
22295 static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};
22296 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
22297 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
22298 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
22299 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
22300 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
22301 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
22302 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
22303 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
22304 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
22305 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
22306 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
22307 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
22308 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
22309 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
22310 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
22311 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
22312 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
22313 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
22314 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
22315 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
22316 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
22317 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
22318 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
22319 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
22320 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
22321 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
22322 static swig_type_info _swigt__p_wxSimpleHtmlListBox = {"_p_wxSimpleHtmlListBox", 0, 0, 0, 0, 0};
22323 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
22324 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
22325 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
22326 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
22327 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
22328 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
22329 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
22330 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
22331 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
22332 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
22333 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
22334 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
22335 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
22336 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
22337 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
22338 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
22339 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
22340 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
22341 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
22342 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
22343 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
22344 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
22345 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
22346 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
22347 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
22348 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
22349 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
22350 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
22351 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
22352 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
22353 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
22354 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
22355 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
22356 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
22357 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
22358 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
22359 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
22360 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
22361 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
22362 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
22363 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
22364 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
22365 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
22366 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
22367 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
22368 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
22369 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
22370 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
22371 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
22372 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
22373 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
22374 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
22375 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
22376 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
22377 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
22378 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
22379 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
22380 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
22381 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
22382 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
22383 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
22384 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
22385 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
22386 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
22387 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
22388 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
22389 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
22390 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
22391 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
22392 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
22393 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
22394 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
22395 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
22396 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
22397 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
22398 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
22399 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
22400 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
22401 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
22402 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
22403 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
22404 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
22405 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
22406 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
22407 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
22408 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
22409 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
22410 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
22411 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
22412 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
22413 static swig_type_info _swigt__p_wxPen = {"_p_wxPen", "wxPen *", 0, 0, (void*)0, 0};
22414 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
22415 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
22416 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
22417 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
22418 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
22419 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
22420 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
22421 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
22422 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
22423 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
22424 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
22425
22426 static swig_type_info *swig_type_initial[] = {
22427 &_swigt__p_char,
22428 &_swigt__p_form_ops_t,
22429 &_swigt__p_int,
22430 &_swigt__p_long,
22431 &_swigt__p_unsigned_char,
22432 &_swigt__p_unsigned_int,
22433 &_swigt__p_unsigned_long,
22434 &_swigt__p_wxANIHandler,
22435 &_swigt__p_wxAcceleratorTable,
22436 &_swigt__p_wxActivateEvent,
22437 &_swigt__p_wxArrayString,
22438 &_swigt__p_wxBMPHandler,
22439 &_swigt__p_wxBoxSizer,
22440 &_swigt__p_wxCURHandler,
22441 &_swigt__p_wxCalculateLayoutEvent,
22442 &_swigt__p_wxChildFocusEvent,
22443 &_swigt__p_wxClipboardTextEvent,
22444 &_swigt__p_wxCloseEvent,
22445 &_swigt__p_wxColour,
22446 &_swigt__p_wxColourData,
22447 &_swigt__p_wxColourDialog,
22448 &_swigt__p_wxCommandEvent,
22449 &_swigt__p_wxContextMenuEvent,
22450 &_swigt__p_wxControl,
22451 &_swigt__p_wxControlWithItems,
22452 &_swigt__p_wxDC,
22453 &_swigt__p_wxDateEvent,
22454 &_swigt__p_wxDialog,
22455 &_swigt__p_wxDirDialog,
22456 &_swigt__p_wxDisplayChangedEvent,
22457 &_swigt__p_wxDropFilesEvent,
22458 &_swigt__p_wxDuplexMode,
22459 &_swigt__p_wxEraseEvent,
22460 &_swigt__p_wxEvent,
22461 &_swigt__p_wxEvtHandler,
22462 &_swigt__p_wxFSFile,
22463 &_swigt__p_wxFileDialog,
22464 &_swigt__p_wxFileSystem,
22465 &_swigt__p_wxFindDialogEvent,
22466 &_swigt__p_wxFindReplaceData,
22467 &_swigt__p_wxFindReplaceDialog,
22468 &_swigt__p_wxFlexGridSizer,
22469 &_swigt__p_wxFocusEvent,
22470 &_swigt__p_wxFont,
22471 &_swigt__p_wxFontData,
22472 &_swigt__p_wxFontDialog,
22473 &_swigt__p_wxFrame,
22474 &_swigt__p_wxGBSizerItem,
22475 &_swigt__p_wxGIFHandler,
22476 &_swigt__p_wxGrid,
22477 &_swigt__p_wxGridBagSizer,
22478 &_swigt__p_wxGridCellAttr,
22479 &_swigt__p_wxGridCellAttrProvider,
22480 &_swigt__p_wxGridCellAutoWrapStringEditor,
22481 &_swigt__p_wxGridCellAutoWrapStringRenderer,
22482 &_swigt__p_wxGridCellBoolEditor,
22483 &_swigt__p_wxGridCellBoolRenderer,
22484 &_swigt__p_wxGridCellChoiceEditor,
22485 &_swigt__p_wxGridCellCoords,
22486 &_swigt__p_wxGridCellDateTimeRenderer,
22487 &_swigt__p_wxGridCellEditor,
22488 &_swigt__p_wxGridCellEnumEditor,
22489 &_swigt__p_wxGridCellEnumRenderer,
22490 &_swigt__p_wxGridCellFloatEditor,
22491 &_swigt__p_wxGridCellFloatRenderer,
22492 &_swigt__p_wxGridCellNumberEditor,
22493 &_swigt__p_wxGridCellNumberRenderer,
22494 &_swigt__p_wxGridCellRenderer,
22495 &_swigt__p_wxGridCellStringRenderer,
22496 &_swigt__p_wxGridCellTextEditor,
22497 &_swigt__p_wxGridCellWorker,
22498 &_swigt__p_wxGridEditorCreatedEvent,
22499 &_swigt__p_wxGridEvent,
22500 &_swigt__p_wxGridRangeSelectEvent,
22501 &_swigt__p_wxGridSizeEvent,
22502 &_swigt__p_wxGridSizer,
22503 &_swigt__p_wxGridStringTable,
22504 &_swigt__p_wxGridTableBase,
22505 &_swigt__p_wxGridTableMessage,
22506 &_swigt__p_wxICOHandler,
22507 &_swigt__p_wxIconizeEvent,
22508 &_swigt__p_wxIdleEvent,
22509 &_swigt__p_wxImage,
22510 &_swigt__p_wxImageHandler,
22511 &_swigt__p_wxIndividualLayoutConstraint,
22512 &_swigt__p_wxInitDialogEvent,
22513 &_swigt__p_wxJPEGHandler,
22514 &_swigt__p_wxKeyEvent,
22515 &_swigt__p_wxLayoutAlgorithm,
22516 &_swigt__p_wxLayoutConstraints,
22517 &_swigt__p_wxMDIChildFrame,
22518 &_swigt__p_wxMDIClientWindow,
22519 &_swigt__p_wxMDIParentFrame,
22520 &_swigt__p_wxMaximizeEvent,
22521 &_swigt__p_wxMenu,
22522 &_swigt__p_wxMenuBar,
22523 &_swigt__p_wxMenuEvent,
22524 &_swigt__p_wxMenuItem,
22525 &_swigt__p_wxMessageDialog,
22526 &_swigt__p_wxMiniFrame,
22527 &_swigt__p_wxMouseCaptureChangedEvent,
22528 &_swigt__p_wxMouseCaptureLostEvent,
22529 &_swigt__p_wxMouseEvent,
22530 &_swigt__p_wxMoveEvent,
22531 &_swigt__p_wxMultiChoiceDialog,
22532 &_swigt__p_wxNavigationKeyEvent,
22533 &_swigt__p_wxNcPaintEvent,
22534 &_swigt__p_wxNotifyEvent,
22535 &_swigt__p_wxNumberEntryDialog,
22536 &_swigt__p_wxObject,
22537 &_swigt__p_wxPCXHandler,
22538 &_swigt__p_wxPNGHandler,
22539 &_swigt__p_wxPNMHandler,
22540 &_swigt__p_wxPageSetupDialog,
22541 &_swigt__p_wxPageSetupDialogData,
22542 &_swigt__p_wxPaintEvent,
22543 &_swigt__p_wxPaletteChangedEvent,
22544 &_swigt__p_wxPanel,
22545 &_swigt__p_wxPaperSize,
22546 &_swigt__p_wxPasswordEntryDialog,
22547 &_swigt__p_wxPen,
22548 &_swigt__p_wxPoint,
22549 &_swigt__p_wxPopupWindow,
22550 &_swigt__p_wxPreviewCanvas,
22551 &_swigt__p_wxPreviewControlBar,
22552 &_swigt__p_wxPreviewFrame,
22553 &_swigt__p_wxPrintData,
22554 &_swigt__p_wxPrintDialog,
22555 &_swigt__p_wxPrintDialogData,
22556 &_swigt__p_wxPrintPreview,
22557 &_swigt__p_wxPrinter,
22558 &_swigt__p_wxProgressDialog,
22559 &_swigt__p_wxPyApp,
22560 &_swigt__p_wxPyCommandEvent,
22561 &_swigt__p_wxPyEvent,
22562 &_swigt__p_wxPyGridCellAttrProvider,
22563 &_swigt__p_wxPyGridCellEditor,
22564 &_swigt__p_wxPyGridCellRenderer,
22565 &_swigt__p_wxPyGridTableBase,
22566 &_swigt__p_wxPyHtmlListBox,
22567 &_swigt__p_wxPyImageHandler,
22568 &_swigt__p_wxPyPanel,
22569 &_swigt__p_wxPyPopupTransientWindow,
22570 &_swigt__p_wxPyPreviewControlBar,
22571 &_swigt__p_wxPyPreviewFrame,
22572 &_swigt__p_wxPyPrintPreview,
22573 &_swigt__p_wxPyPrintout,
22574 &_swigt__p_wxPyScrolledWindow,
22575 &_swigt__p_wxPySizer,
22576 &_swigt__p_wxPyTaskBarIcon,
22577 &_swigt__p_wxPyVListBox,
22578 &_swigt__p_wxPyVScrolledWindow,
22579 &_swigt__p_wxPyValidator,
22580 &_swigt__p_wxPyWindow,
22581 &_swigt__p_wxQueryLayoutInfoEvent,
22582 &_swigt__p_wxQueryNewPaletteEvent,
22583 &_swigt__p_wxRect,
22584 &_swigt__p_wxSashEvent,
22585 &_swigt__p_wxSashLayoutWindow,
22586 &_swigt__p_wxSashWindow,
22587 &_swigt__p_wxScrollEvent,
22588 &_swigt__p_wxScrollWinEvent,
22589 &_swigt__p_wxScrolledWindow,
22590 &_swigt__p_wxSetCursorEvent,
22591 &_swigt__p_wxShowEvent,
22592 &_swigt__p_wxSimpleHtmlListBox,
22593 &_swigt__p_wxSingleChoiceDialog,
22594 &_swigt__p_wxSize,
22595 &_swigt__p_wxSizeEvent,
22596 &_swigt__p_wxSizer,
22597 &_swigt__p_wxSizerItem,
22598 &_swigt__p_wxSplashScreen,
22599 &_swigt__p_wxSplashScreenWindow,
22600 &_swigt__p_wxSplitterEvent,
22601 &_swigt__p_wxSplitterWindow,
22602 &_swigt__p_wxStaticBoxSizer,
22603 &_swigt__p_wxStatusBar,
22604 &_swigt__p_wxStdDialogButtonSizer,
22605 &_swigt__p_wxString,
22606 &_swigt__p_wxSysColourChangedEvent,
22607 &_swigt__p_wxTGAHandler,
22608 &_swigt__p_wxTIFFHandler,
22609 &_swigt__p_wxTaskBarIconEvent,
22610 &_swigt__p_wxTextEntryDialog,
22611 &_swigt__p_wxTipWindow,
22612 &_swigt__p_wxTopLevelWindow,
22613 &_swigt__p_wxUpdateUIEvent,
22614 &_swigt__p_wxValidator,
22615 &_swigt__p_wxVisualAttributes,
22616 &_swigt__p_wxWindow,
22617 &_swigt__p_wxWindowCreateEvent,
22618 &_swigt__p_wxWindowDestroyEvent,
22619 &_swigt__p_wxXPMHandler,
22620 };
22621
22622 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22623 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
22624 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22625 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
22626 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
22627 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22628 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
22629 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
22630 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
22631 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
22632 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
22633 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
22634 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
22635 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
22636 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
22637 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22638 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22639 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
22640 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
22641 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22642 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
22643 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}};
22644 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
22645 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}};
22646 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
22647 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
22648 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
22649 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
22650 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
22651 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
22652 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
22653 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22654 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22655 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
22656 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22657 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22658 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22659 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22660 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22661 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22662 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22663 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22664 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22665 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22666 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22667 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22668 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22669 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22670 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22671 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22672 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22673 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22674 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22675 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22676 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22677 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}};
22678 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22679 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22680 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22681 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22682 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22683 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22684 static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22685 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22686 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22687 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22688 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22689 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22690 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22691 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22692 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22693 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22694 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22695 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22696 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22697 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22698 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22699 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22700 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22701 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22702 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22703 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22704 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22705 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22706 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22707 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22708 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22709 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22710 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22711 static swig_cast_info _swigc__p_wxSimpleHtmlListBox[] = {{&_swigt__p_wxSimpleHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22712 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22713 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22714 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22715 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22716 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22717 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22718 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22719 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22720 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22721 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22722 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22723 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22724 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_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_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22725 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22726 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22727 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22728 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}};
22729 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22730 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22731 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22732 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22733 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}};
22734 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22735 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22736 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}};
22737 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22738 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22739 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22740 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22741 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22742 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22743 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}};
22744 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}};
22745 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}};
22746 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}};
22747 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22748 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22749 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22750 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22751 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22752 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}};
22753 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22754 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22755 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}};
22756 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22757 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22758 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22759 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22760 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22761 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22762 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22763 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22764 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22765 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22766 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22767 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22768 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22769 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22770 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22771 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22772 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22773 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22774 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22775 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22776 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22777 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22778 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22779 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22780 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22781 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22782 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22783 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22784 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22785 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22786 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22787 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22788 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
22789 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22790 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22791 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22792 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22793 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22794 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22795 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22796 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22797 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22798 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22799 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22800 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_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_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_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_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22801 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
22802 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22803 static swig_cast_info _swigc__p_wxPen[] = { {&_swigt__p_wxPen, 0, 0, 0},{0, 0, 0, 0}};
22804 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22805 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22806 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22807 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22808 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22809 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22810 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}};
22811 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
22812 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22813 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22814 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_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_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22815
22816 static swig_cast_info *swig_cast_initial[] = {
22817 _swigc__p_char,
22818 _swigc__p_form_ops_t,
22819 _swigc__p_int,
22820 _swigc__p_long,
22821 _swigc__p_unsigned_char,
22822 _swigc__p_unsigned_int,
22823 _swigc__p_unsigned_long,
22824 _swigc__p_wxANIHandler,
22825 _swigc__p_wxAcceleratorTable,
22826 _swigc__p_wxActivateEvent,
22827 _swigc__p_wxArrayString,
22828 _swigc__p_wxBMPHandler,
22829 _swigc__p_wxBoxSizer,
22830 _swigc__p_wxCURHandler,
22831 _swigc__p_wxCalculateLayoutEvent,
22832 _swigc__p_wxChildFocusEvent,
22833 _swigc__p_wxClipboardTextEvent,
22834 _swigc__p_wxCloseEvent,
22835 _swigc__p_wxColour,
22836 _swigc__p_wxColourData,
22837 _swigc__p_wxColourDialog,
22838 _swigc__p_wxCommandEvent,
22839 _swigc__p_wxContextMenuEvent,
22840 _swigc__p_wxControl,
22841 _swigc__p_wxControlWithItems,
22842 _swigc__p_wxDC,
22843 _swigc__p_wxDateEvent,
22844 _swigc__p_wxDialog,
22845 _swigc__p_wxDirDialog,
22846 _swigc__p_wxDisplayChangedEvent,
22847 _swigc__p_wxDropFilesEvent,
22848 _swigc__p_wxDuplexMode,
22849 _swigc__p_wxEraseEvent,
22850 _swigc__p_wxEvent,
22851 _swigc__p_wxEvtHandler,
22852 _swigc__p_wxFSFile,
22853 _swigc__p_wxFileDialog,
22854 _swigc__p_wxFileSystem,
22855 _swigc__p_wxFindDialogEvent,
22856 _swigc__p_wxFindReplaceData,
22857 _swigc__p_wxFindReplaceDialog,
22858 _swigc__p_wxFlexGridSizer,
22859 _swigc__p_wxFocusEvent,
22860 _swigc__p_wxFont,
22861 _swigc__p_wxFontData,
22862 _swigc__p_wxFontDialog,
22863 _swigc__p_wxFrame,
22864 _swigc__p_wxGBSizerItem,
22865 _swigc__p_wxGIFHandler,
22866 _swigc__p_wxGrid,
22867 _swigc__p_wxGridBagSizer,
22868 _swigc__p_wxGridCellAttr,
22869 _swigc__p_wxGridCellAttrProvider,
22870 _swigc__p_wxGridCellAutoWrapStringEditor,
22871 _swigc__p_wxGridCellAutoWrapStringRenderer,
22872 _swigc__p_wxGridCellBoolEditor,
22873 _swigc__p_wxGridCellBoolRenderer,
22874 _swigc__p_wxGridCellChoiceEditor,
22875 _swigc__p_wxGridCellCoords,
22876 _swigc__p_wxGridCellDateTimeRenderer,
22877 _swigc__p_wxGridCellEditor,
22878 _swigc__p_wxGridCellEnumEditor,
22879 _swigc__p_wxGridCellEnumRenderer,
22880 _swigc__p_wxGridCellFloatEditor,
22881 _swigc__p_wxGridCellFloatRenderer,
22882 _swigc__p_wxGridCellNumberEditor,
22883 _swigc__p_wxGridCellNumberRenderer,
22884 _swigc__p_wxGridCellRenderer,
22885 _swigc__p_wxGridCellStringRenderer,
22886 _swigc__p_wxGridCellTextEditor,
22887 _swigc__p_wxGridCellWorker,
22888 _swigc__p_wxGridEditorCreatedEvent,
22889 _swigc__p_wxGridEvent,
22890 _swigc__p_wxGridRangeSelectEvent,
22891 _swigc__p_wxGridSizeEvent,
22892 _swigc__p_wxGridSizer,
22893 _swigc__p_wxGridStringTable,
22894 _swigc__p_wxGridTableBase,
22895 _swigc__p_wxGridTableMessage,
22896 _swigc__p_wxICOHandler,
22897 _swigc__p_wxIconizeEvent,
22898 _swigc__p_wxIdleEvent,
22899 _swigc__p_wxImage,
22900 _swigc__p_wxImageHandler,
22901 _swigc__p_wxIndividualLayoutConstraint,
22902 _swigc__p_wxInitDialogEvent,
22903 _swigc__p_wxJPEGHandler,
22904 _swigc__p_wxKeyEvent,
22905 _swigc__p_wxLayoutAlgorithm,
22906 _swigc__p_wxLayoutConstraints,
22907 _swigc__p_wxMDIChildFrame,
22908 _swigc__p_wxMDIClientWindow,
22909 _swigc__p_wxMDIParentFrame,
22910 _swigc__p_wxMaximizeEvent,
22911 _swigc__p_wxMenu,
22912 _swigc__p_wxMenuBar,
22913 _swigc__p_wxMenuEvent,
22914 _swigc__p_wxMenuItem,
22915 _swigc__p_wxMessageDialog,
22916 _swigc__p_wxMiniFrame,
22917 _swigc__p_wxMouseCaptureChangedEvent,
22918 _swigc__p_wxMouseCaptureLostEvent,
22919 _swigc__p_wxMouseEvent,
22920 _swigc__p_wxMoveEvent,
22921 _swigc__p_wxMultiChoiceDialog,
22922 _swigc__p_wxNavigationKeyEvent,
22923 _swigc__p_wxNcPaintEvent,
22924 _swigc__p_wxNotifyEvent,
22925 _swigc__p_wxNumberEntryDialog,
22926 _swigc__p_wxObject,
22927 _swigc__p_wxPCXHandler,
22928 _swigc__p_wxPNGHandler,
22929 _swigc__p_wxPNMHandler,
22930 _swigc__p_wxPageSetupDialog,
22931 _swigc__p_wxPageSetupDialogData,
22932 _swigc__p_wxPaintEvent,
22933 _swigc__p_wxPaletteChangedEvent,
22934 _swigc__p_wxPanel,
22935 _swigc__p_wxPaperSize,
22936 _swigc__p_wxPasswordEntryDialog,
22937 _swigc__p_wxPen,
22938 _swigc__p_wxPoint,
22939 _swigc__p_wxPopupWindow,
22940 _swigc__p_wxPreviewCanvas,
22941 _swigc__p_wxPreviewControlBar,
22942 _swigc__p_wxPreviewFrame,
22943 _swigc__p_wxPrintData,
22944 _swigc__p_wxPrintDialog,
22945 _swigc__p_wxPrintDialogData,
22946 _swigc__p_wxPrintPreview,
22947 _swigc__p_wxPrinter,
22948 _swigc__p_wxProgressDialog,
22949 _swigc__p_wxPyApp,
22950 _swigc__p_wxPyCommandEvent,
22951 _swigc__p_wxPyEvent,
22952 _swigc__p_wxPyGridCellAttrProvider,
22953 _swigc__p_wxPyGridCellEditor,
22954 _swigc__p_wxPyGridCellRenderer,
22955 _swigc__p_wxPyGridTableBase,
22956 _swigc__p_wxPyHtmlListBox,
22957 _swigc__p_wxPyImageHandler,
22958 _swigc__p_wxPyPanel,
22959 _swigc__p_wxPyPopupTransientWindow,
22960 _swigc__p_wxPyPreviewControlBar,
22961 _swigc__p_wxPyPreviewFrame,
22962 _swigc__p_wxPyPrintPreview,
22963 _swigc__p_wxPyPrintout,
22964 _swigc__p_wxPyScrolledWindow,
22965 _swigc__p_wxPySizer,
22966 _swigc__p_wxPyTaskBarIcon,
22967 _swigc__p_wxPyVListBox,
22968 _swigc__p_wxPyVScrolledWindow,
22969 _swigc__p_wxPyValidator,
22970 _swigc__p_wxPyWindow,
22971 _swigc__p_wxQueryLayoutInfoEvent,
22972 _swigc__p_wxQueryNewPaletteEvent,
22973 _swigc__p_wxRect,
22974 _swigc__p_wxSashEvent,
22975 _swigc__p_wxSashLayoutWindow,
22976 _swigc__p_wxSashWindow,
22977 _swigc__p_wxScrollEvent,
22978 _swigc__p_wxScrollWinEvent,
22979 _swigc__p_wxScrolledWindow,
22980 _swigc__p_wxSetCursorEvent,
22981 _swigc__p_wxShowEvent,
22982 _swigc__p_wxSimpleHtmlListBox,
22983 _swigc__p_wxSingleChoiceDialog,
22984 _swigc__p_wxSize,
22985 _swigc__p_wxSizeEvent,
22986 _swigc__p_wxSizer,
22987 _swigc__p_wxSizerItem,
22988 _swigc__p_wxSplashScreen,
22989 _swigc__p_wxSplashScreenWindow,
22990 _swigc__p_wxSplitterEvent,
22991 _swigc__p_wxSplitterWindow,
22992 _swigc__p_wxStaticBoxSizer,
22993 _swigc__p_wxStatusBar,
22994 _swigc__p_wxStdDialogButtonSizer,
22995 _swigc__p_wxString,
22996 _swigc__p_wxSysColourChangedEvent,
22997 _swigc__p_wxTGAHandler,
22998 _swigc__p_wxTIFFHandler,
22999 _swigc__p_wxTaskBarIconEvent,
23000 _swigc__p_wxTextEntryDialog,
23001 _swigc__p_wxTipWindow,
23002 _swigc__p_wxTopLevelWindow,
23003 _swigc__p_wxUpdateUIEvent,
23004 _swigc__p_wxValidator,
23005 _swigc__p_wxVisualAttributes,
23006 _swigc__p_wxWindow,
23007 _swigc__p_wxWindowCreateEvent,
23008 _swigc__p_wxWindowDestroyEvent,
23009 _swigc__p_wxXPMHandler,
23010 };
23011
23012
23013 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23014
23015 static swig_const_info swig_const_table[] = {
23016 {0, 0, 0, 0.0, 0, 0}};
23017
23018 #ifdef __cplusplus
23019 }
23020 #endif
23021 /* -----------------------------------------------------------------------------
23022 * Type initialization:
23023 * This problem is tough by the requirement that no dynamic
23024 * memory is used. Also, since swig_type_info structures store pointers to
23025 * swig_cast_info structures and swig_cast_info structures store pointers back
23026 * to swig_type_info structures, we need some lookup code at initialization.
23027 * The idea is that swig generates all the structures that are needed.
23028 * The runtime then collects these partially filled structures.
23029 * The SWIG_InitializeModule function takes these initial arrays out of
23030 * swig_module, and does all the lookup, filling in the swig_module.types
23031 * array with the correct data and linking the correct swig_cast_info
23032 * structures together.
23033 *
23034 * The generated swig_type_info structures are assigned staticly to an initial
23035 * array. We just loop though that array, and handle each type individually.
23036 * First we lookup if this type has been already loaded, and if so, use the
23037 * loaded structure instead of the generated one. Then we have to fill in the
23038 * cast linked list. The cast data is initially stored in something like a
23039 * two-dimensional array. Each row corresponds to a type (there are the same
23040 * number of rows as there are in the swig_type_initial array). Each entry in
23041 * a column is one of the swig_cast_info structures for that type.
23042 * The cast_initial array is actually an array of arrays, because each row has
23043 * a variable number of columns. So to actually build the cast linked list,
23044 * we find the array of casts associated with the type, and loop through it
23045 * adding the casts to the list. The one last trick we need to do is making
23046 * sure the type pointer in the swig_cast_info struct is correct.
23047 *
23048 * First off, we lookup the cast->type name to see if it is already loaded.
23049 * There are three cases to handle:
23050 * 1) If the cast->type has already been loaded AND the type we are adding
23051 * casting info to has not been loaded (it is in this module), THEN we
23052 * replace the cast->type pointer with the type pointer that has already
23053 * been loaded.
23054 * 2) If BOTH types (the one we are adding casting info to, and the
23055 * cast->type) are loaded, THEN the cast info has already been loaded by
23056 * the previous module so we just ignore it.
23057 * 3) Finally, if cast->type has not already been loaded, then we add that
23058 * swig_cast_info to the linked list (because the cast->type) pointer will
23059 * be correct.
23060 * ----------------------------------------------------------------------------- */
23061
23062 #ifdef __cplusplus
23063 extern "C" {
23064 #if 0
23065 } /* c-mode */
23066 #endif
23067 #endif
23068
23069 #if 0
23070 #define SWIGRUNTIME_DEBUG
23071 #endif
23072
23073 SWIGRUNTIME void
23074 SWIG_InitializeModule(void *clientdata) {
23075 size_t i;
23076 swig_module_info *module_head;
23077 static int init_run = 0;
23078
23079 clientdata = clientdata;
23080
23081 if (init_run) return;
23082 init_run = 1;
23083
23084 /* Initialize the swig_module */
23085 swig_module.type_initial = swig_type_initial;
23086 swig_module.cast_initial = swig_cast_initial;
23087
23088 /* Try and load any already created modules */
23089 module_head = SWIG_GetModule(clientdata);
23090 if (module_head) {
23091 swig_module.next = module_head->next;
23092 module_head->next = &swig_module;
23093 } else {
23094 /* This is the first module loaded */
23095 swig_module.next = &swig_module;
23096 SWIG_SetModule(clientdata, &swig_module);
23097 }
23098
23099 /* Now work on filling in swig_module.types */
23100 #ifdef SWIGRUNTIME_DEBUG
23101 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23102 #endif
23103 for (i = 0; i < swig_module.size; ++i) {
23104 swig_type_info *type = 0;
23105 swig_type_info *ret;
23106 swig_cast_info *cast;
23107
23108 #ifdef SWIGRUNTIME_DEBUG
23109 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23110 #endif
23111
23112 /* if there is another module already loaded */
23113 if (swig_module.next != &swig_module) {
23114 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23115 }
23116 if (type) {
23117 /* Overwrite clientdata field */
23118 #ifdef SWIGRUNTIME_DEBUG
23119 printf("SWIG_InitializeModule: found type %s\n", type->name);
23120 #endif
23121 if (swig_module.type_initial[i]->clientdata) {
23122 type->clientdata = swig_module.type_initial[i]->clientdata;
23123 #ifdef SWIGRUNTIME_DEBUG
23124 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23125 #endif
23126 }
23127 } else {
23128 type = swig_module.type_initial[i];
23129 }
23130
23131 /* Insert casting types */
23132 cast = swig_module.cast_initial[i];
23133 while (cast->type) {
23134 /* Don't need to add information already in the list */
23135 ret = 0;
23136 #ifdef SWIGRUNTIME_DEBUG
23137 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23138 #endif
23139 if (swig_module.next != &swig_module) {
23140 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23141 #ifdef SWIGRUNTIME_DEBUG
23142 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23143 #endif
23144 }
23145 if (ret) {
23146 if (type == swig_module.type_initial[i]) {
23147 #ifdef SWIGRUNTIME_DEBUG
23148 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23149 #endif
23150 cast->type = ret;
23151 ret = 0;
23152 } else {
23153 /* Check for casting already in the list */
23154 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23155 #ifdef SWIGRUNTIME_DEBUG
23156 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23157 #endif
23158 if (!ocast) ret = 0;
23159 }
23160 }
23161
23162 if (!ret) {
23163 #ifdef SWIGRUNTIME_DEBUG
23164 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23165 #endif
23166 if (type->cast) {
23167 type->cast->prev = cast;
23168 cast->next = type->cast;
23169 }
23170 type->cast = cast;
23171 }
23172 cast++;
23173 }
23174 /* Set entry in modules->types array equal to the type */
23175 swig_module.types[i] = type;
23176 }
23177 swig_module.types[i] = 0;
23178
23179 #ifdef SWIGRUNTIME_DEBUG
23180 printf("**** SWIG_InitializeModule: Cast List ******\n");
23181 for (i = 0; i < swig_module.size; ++i) {
23182 int j = 0;
23183 swig_cast_info *cast = swig_module.cast_initial[i];
23184 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23185 while (cast->type) {
23186 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23187 cast++;
23188 ++j;
23189 }
23190 printf("---- Total casts: %d\n",j);
23191 }
23192 printf("**** SWIG_InitializeModule: Cast List ******\n");
23193 #endif
23194 }
23195
23196 /* This function will propagate the clientdata field of type to
23197 * any new swig_type_info structures that have been added into the list
23198 * of equivalent types. It is like calling
23199 * SWIG_TypeClientData(type, clientdata) a second time.
23200 */
23201 SWIGRUNTIME void
23202 SWIG_PropagateClientData(void) {
23203 size_t i;
23204 swig_cast_info *equiv;
23205 static int init_run = 0;
23206
23207 if (init_run) return;
23208 init_run = 1;
23209
23210 for (i = 0; i < swig_module.size; i++) {
23211 if (swig_module.types[i]->clientdata) {
23212 equiv = swig_module.types[i]->cast;
23213 while (equiv) {
23214 if (!equiv->converter) {
23215 if (equiv->type && !equiv->type->clientdata)
23216 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23217 }
23218 equiv = equiv->next;
23219 }
23220 }
23221 }
23222 }
23223
23224 #ifdef __cplusplus
23225 #if 0
23226 {
23227 /* c-mode */
23228 #endif
23229 }
23230 #endif
23231
23232
23233
23234 #ifdef __cplusplus
23235 extern "C" {
23236 #endif
23237
23238 /* Python-specific SWIG API */
23239 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23240 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23241 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23242
23243 /* -----------------------------------------------------------------------------
23244 * global variable support code.
23245 * ----------------------------------------------------------------------------- */
23246
23247 typedef struct swig_globalvar {
23248 char *name; /* Name of global variable */
23249 PyObject *(*get_attr)(void); /* Return the current value */
23250 int (*set_attr)(PyObject *); /* Set the value */
23251 struct swig_globalvar *next;
23252 } swig_globalvar;
23253
23254 typedef struct swig_varlinkobject {
23255 PyObject_HEAD
23256 swig_globalvar *vars;
23257 } swig_varlinkobject;
23258
23259 SWIGINTERN PyObject *
23260 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23261 return PyString_FromString("<Swig global variables>");
23262 }
23263
23264 SWIGINTERN PyObject *
23265 swig_varlink_str(swig_varlinkobject *v) {
23266 PyObject *str = PyString_FromString("(");
23267 swig_globalvar *var;
23268 for (var = v->vars; var; var=var->next) {
23269 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23270 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23271 }
23272 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23273 return str;
23274 }
23275
23276 SWIGINTERN int
23277 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23278 PyObject *str = swig_varlink_str(v);
23279 fprintf(fp,"Swig global variables ");
23280 fprintf(fp,"%s\n", PyString_AsString(str));
23281 Py_DECREF(str);
23282 return 0;
23283 }
23284
23285 SWIGINTERN void
23286 swig_varlink_dealloc(swig_varlinkobject *v) {
23287 swig_globalvar *var = v->vars;
23288 while (var) {
23289 swig_globalvar *n = var->next;
23290 free(var->name);
23291 free(var);
23292 var = n;
23293 }
23294 }
23295
23296 SWIGINTERN PyObject *
23297 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23298 PyObject *res = NULL;
23299 swig_globalvar *var = v->vars;
23300 while (var) {
23301 if (strcmp(var->name,n) == 0) {
23302 res = (*var->get_attr)();
23303 break;
23304 }
23305 var = var->next;
23306 }
23307 if (res == NULL && !PyErr_Occurred()) {
23308 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23309 }
23310 return res;
23311 }
23312
23313 SWIGINTERN int
23314 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23315 int res = 1;
23316 swig_globalvar *var = v->vars;
23317 while (var) {
23318 if (strcmp(var->name,n) == 0) {
23319 res = (*var->set_attr)(p);
23320 break;
23321 }
23322 var = var->next;
23323 }
23324 if (res == 1 && !PyErr_Occurred()) {
23325 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23326 }
23327 return res;
23328 }
23329
23330 SWIGINTERN PyTypeObject*
23331 swig_varlink_type(void) {
23332 static char varlink__doc__[] = "Swig var link object";
23333 static PyTypeObject varlink_type;
23334 static int type_init = 0;
23335 if (!type_init) {
23336 const PyTypeObject tmp
23337 = {
23338 PyObject_HEAD_INIT(NULL)
23339 0, /* Number of items in variable part (ob_size) */
23340 (char *)"swigvarlink", /* Type name (tp_name) */
23341 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23342 0, /* Itemsize (tp_itemsize) */
23343 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
23344 (printfunc) swig_varlink_print, /* Print (tp_print) */
23345 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23346 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23347 0, /* tp_compare */
23348 (reprfunc) swig_varlink_repr, /* tp_repr */
23349 0, /* tp_as_number */
23350 0, /* tp_as_sequence */
23351 0, /* tp_as_mapping */
23352 0, /* tp_hash */
23353 0, /* tp_call */
23354 (reprfunc)swig_varlink_str, /* tp_str */
23355 0, /* tp_getattro */
23356 0, /* tp_setattro */
23357 0, /* tp_as_buffer */
23358 0, /* tp_flags */
23359 varlink__doc__, /* tp_doc */
23360 0, /* tp_traverse */
23361 0, /* tp_clear */
23362 0, /* tp_richcompare */
23363 0, /* tp_weaklistoffset */
23364 #if PY_VERSION_HEX >= 0x02020000
23365 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23366 #endif
23367 #if PY_VERSION_HEX >= 0x02030000
23368 0, /* tp_del */
23369 #endif
23370 #ifdef COUNT_ALLOCS
23371 0,0,0,0 /* tp_alloc -> tp_next */
23372 #endif
23373 };
23374 varlink_type = tmp;
23375 varlink_type.ob_type = &PyType_Type;
23376 type_init = 1;
23377 }
23378 return &varlink_type;
23379 }
23380
23381 /* Create a variable linking object for use later */
23382 SWIGINTERN PyObject *
23383 SWIG_Python_newvarlink(void) {
23384 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23385 if (result) {
23386 result->vars = 0;
23387 }
23388 return ((PyObject*) result);
23389 }
23390
23391 SWIGINTERN void
23392 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23393 swig_varlinkobject *v = (swig_varlinkobject *) p;
23394 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23395 if (gv) {
23396 size_t size = strlen(name)+1;
23397 gv->name = (char *)malloc(size);
23398 if (gv->name) {
23399 strncpy(gv->name,name,size);
23400 gv->get_attr = get_attr;
23401 gv->set_attr = set_attr;
23402 gv->next = v->vars;
23403 }
23404 }
23405 v->vars = gv;
23406 }
23407
23408 SWIGINTERN PyObject *
23409 SWIG_globals() {
23410 static PyObject *_SWIG_globals = 0;
23411 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23412 return _SWIG_globals;
23413 }
23414
23415 /* -----------------------------------------------------------------------------
23416 * constants/methods manipulation
23417 * ----------------------------------------------------------------------------- */
23418
23419 /* Install Constants */
23420 SWIGINTERN void
23421 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23422 PyObject *obj = 0;
23423 size_t i;
23424 for (i = 0; constants[i].type; ++i) {
23425 switch(constants[i].type) {
23426 case SWIG_PY_POINTER:
23427 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23428 break;
23429 case SWIG_PY_BINARY:
23430 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23431 break;
23432 default:
23433 obj = 0;
23434 break;
23435 }
23436 if (obj) {
23437 PyDict_SetItemString(d, constants[i].name, obj);
23438 Py_DECREF(obj);
23439 }
23440 }
23441 }
23442
23443 /* -----------------------------------------------------------------------------*/
23444 /* Fix SwigMethods to carry the callback ptrs when needed */
23445 /* -----------------------------------------------------------------------------*/
23446
23447 SWIGINTERN void
23448 SWIG_Python_FixMethods(PyMethodDef *methods,
23449 swig_const_info *const_table,
23450 swig_type_info **types,
23451 swig_type_info **types_initial) {
23452 size_t i;
23453 for (i = 0; methods[i].ml_name; ++i) {
23454 const char *c = methods[i].ml_doc;
23455 if (c && (c = strstr(c, "swig_ptr: "))) {
23456 int j;
23457 swig_const_info *ci = 0;
23458 const char *name = c + 10;
23459 for (j = 0; const_table[j].type; ++j) {
23460 if (strncmp(const_table[j].name, name,
23461 strlen(const_table[j].name)) == 0) {
23462 ci = &(const_table[j]);
23463 break;
23464 }
23465 }
23466 if (ci) {
23467 size_t shift = (ci->ptype) - types;
23468 swig_type_info *ty = types_initial[shift];
23469 size_t ldoc = (c - methods[i].ml_doc);
23470 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23471 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23472 if (ndoc) {
23473 char *buff = ndoc;
23474 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23475 if (ptr) {
23476 strncpy(buff, methods[i].ml_doc, ldoc);
23477 buff += ldoc;
23478 strncpy(buff, "swig_ptr: ", 10);
23479 buff += 10;
23480 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23481 methods[i].ml_doc = ndoc;
23482 }
23483 }
23484 }
23485 }
23486 }
23487 }
23488
23489 #ifdef __cplusplus
23490 }
23491 #endif
23492
23493 /* -----------------------------------------------------------------------------*
23494 * Partial Init method
23495 * -----------------------------------------------------------------------------*/
23496
23497 #ifdef __cplusplus
23498 extern "C"
23499 #endif
23500 SWIGEXPORT void SWIG_init(void) {
23501 PyObject *m, *d;
23502
23503 /* Fix SwigMethods to carry the callback ptrs when needed */
23504 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23505
23506 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23507 d = PyModule_GetDict(m);
23508
23509 SWIG_InitializeModule(0);
23510 SWIG_InstallConstants(d,swig_const_table);
23511
23512
23513 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
23514 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
23515 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
23516 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
23517 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
23518 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
23519 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
23520 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
23521 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
23522 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
23523 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
23524 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
23525 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
23526 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
23527 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
23528 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
23529 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
23530 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
23531 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
23532 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
23533 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
23534 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
23535 SWIG_addvarlink(SWIG_globals(),(char*)"OneString",OneString_get, OneString_set);
23536 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
23537 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
23538 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
23539 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
23540 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
23541 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
23542 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
23543 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
23544 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
23545 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
23546 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
23547 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
23548 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
23549 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
23550 SWIG_Python_SetConstant(d, "Grid_wxGridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
23551 SWIG_Python_SetConstant(d, "Grid_wxGridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
23552 SWIG_Python_SetConstant(d, "Grid_wxGridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
23553 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
23554 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
23555 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
23556 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
23557 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
23558 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
23559 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
23560 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
23561 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
23562 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
23563 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
23564 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
23565 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
23566 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
23567 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
23568 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
23569 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
23570
23571
23572 }
23573
wxWidgets (Impactor)