]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/grid_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / grid_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_long swig_types[3]
2466 #define SWIGTYPE_p_unsigned_char swig_types[4]
2467 #define SWIGTYPE_p_unsigned_int swig_types[5]
2468 #define SWIGTYPE_p_unsigned_long swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2475 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2476 #define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[14]
2477 #define SWIGTYPE_p_wxChildFocusEvent swig_types[15]
2478 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[16]
2479 #define SWIGTYPE_p_wxCloseEvent swig_types[17]
2480 #define SWIGTYPE_p_wxColour swig_types[18]
2481 #define SWIGTYPE_p_wxColourData swig_types[19]
2482 #define SWIGTYPE_p_wxColourDialog swig_types[20]
2483 #define SWIGTYPE_p_wxCommandEvent swig_types[21]
2484 #define SWIGTYPE_p_wxContextMenuEvent swig_types[22]
2485 #define SWIGTYPE_p_wxControl swig_types[23]
2486 #define SWIGTYPE_p_wxControlWithItems swig_types[24]
2487 #define SWIGTYPE_p_wxDC swig_types[25]
2488 #define SWIGTYPE_p_wxDateEvent swig_types[26]
2489 #define SWIGTYPE_p_wxDialog swig_types[27]
2490 #define SWIGTYPE_p_wxDirDialog swig_types[28]
2491 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDropFilesEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDuplexMode swig_types[31]
2494 #define SWIGTYPE_p_wxEraseEvent swig_types[32]
2495 #define SWIGTYPE_p_wxEvent swig_types[33]
2496 #define SWIGTYPE_p_wxEvtHandler swig_types[34]
2497 #define SWIGTYPE_p_wxFSFile swig_types[35]
2498 #define SWIGTYPE_p_wxFileDialog swig_types[36]
2499 #define SWIGTYPE_p_wxFileSystem swig_types[37]
2500 #define SWIGTYPE_p_wxFindDialogEvent swig_types[38]
2501 #define SWIGTYPE_p_wxFindReplaceData swig_types[39]
2502 #define SWIGTYPE_p_wxFindReplaceDialog swig_types[40]
2503 #define SWIGTYPE_p_wxFlexGridSizer swig_types[41]
2504 #define SWIGTYPE_p_wxFocusEvent swig_types[42]
2505 #define SWIGTYPE_p_wxFont swig_types[43]
2506 #define SWIGTYPE_p_wxFontData swig_types[44]
2507 #define SWIGTYPE_p_wxFontDialog swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGIFHandler swig_types[48]
2511 #define SWIGTYPE_p_wxGrid swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridCellAttr swig_types[51]
2514 #define SWIGTYPE_p_wxGridCellAttrProvider swig_types[52]
2515 #define SWIGTYPE_p_wxGridCellAutoWrapStringEditor swig_types[53]
2516 #define SWIGTYPE_p_wxGridCellAutoWrapStringRenderer swig_types[54]
2517 #define SWIGTYPE_p_wxGridCellBoolEditor swig_types[55]
2518 #define SWIGTYPE_p_wxGridCellBoolRenderer swig_types[56]
2519 #define SWIGTYPE_p_wxGridCellChoiceEditor swig_types[57]
2520 #define SWIGTYPE_p_wxGridCellCoords swig_types[58]
2521 #define SWIGTYPE_p_wxGridCellDateTimeRenderer swig_types[59]
2522 #define SWIGTYPE_p_wxGridCellEditor swig_types[60]
2523 #define SWIGTYPE_p_wxGridCellEnumEditor swig_types[61]
2524 #define SWIGTYPE_p_wxGridCellEnumRenderer swig_types[62]
2525 #define SWIGTYPE_p_wxGridCellFloatEditor swig_types[63]
2526 #define SWIGTYPE_p_wxGridCellFloatRenderer swig_types[64]
2527 #define SWIGTYPE_p_wxGridCellNumberEditor swig_types[65]
2528 #define SWIGTYPE_p_wxGridCellNumberRenderer swig_types[66]
2529 #define SWIGTYPE_p_wxGridCellRenderer swig_types[67]
2530 #define SWIGTYPE_p_wxGridCellStringRenderer swig_types[68]
2531 #define SWIGTYPE_p_wxGridCellTextEditor swig_types[69]
2532 #define SWIGTYPE_p_wxGridCellWorker swig_types[70]
2533 #define SWIGTYPE_p_wxGridEditorCreatedEvent swig_types[71]
2534 #define SWIGTYPE_p_wxGridEvent swig_types[72]
2535 #define SWIGTYPE_p_wxGridRangeSelectEvent swig_types[73]
2536 #define SWIGTYPE_p_wxGridSizeEvent swig_types[74]
2537 #define SWIGTYPE_p_wxGridSizer swig_types[75]
2538 #define SWIGTYPE_p_wxGridStringTable swig_types[76]
2539 #define SWIGTYPE_p_wxGridTableBase swig_types[77]
2540 #define SWIGTYPE_p_wxGridTableMessage swig_types[78]
2541 #define SWIGTYPE_p_wxICOHandler swig_types[79]
2542 #define SWIGTYPE_p_wxIconizeEvent swig_types[80]
2543 #define SWIGTYPE_p_wxIdleEvent swig_types[81]
2544 #define SWIGTYPE_p_wxImage swig_types[82]
2545 #define SWIGTYPE_p_wxImageHandler swig_types[83]
2546 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[84]
2547 #define SWIGTYPE_p_wxInitDialogEvent swig_types[85]
2548 #define SWIGTYPE_p_wxJPEGHandler swig_types[86]
2549 #define SWIGTYPE_p_wxKeyEvent swig_types[87]
2550 #define SWIGTYPE_p_wxLayoutAlgorithm swig_types[88]
2551 #define SWIGTYPE_p_wxLayoutConstraints swig_types[89]
2552 #define SWIGTYPE_p_wxMDIChildFrame swig_types[90]
2553 #define SWIGTYPE_p_wxMDIClientWindow swig_types[91]
2554 #define SWIGTYPE_p_wxMDIParentFrame swig_types[92]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2556 #define SWIGTYPE_p_wxMenu swig_types[94]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2560 #define SWIGTYPE_p_wxMessageDialog swig_types[98]
2561 #define SWIGTYPE_p_wxMiniFrame swig_types[99]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[101]
2564 #define SWIGTYPE_p_wxMoveEvent swig_types[102]
2565 #define SWIGTYPE_p_wxMultiChoiceDialog swig_types[103]
2566 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[104]
2567 #define SWIGTYPE_p_wxNcPaintEvent swig_types[105]
2568 #define SWIGTYPE_p_wxNotifyEvent swig_types[106]
2569 #define SWIGTYPE_p_wxObject swig_types[107]
2570 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2572 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2573 #define SWIGTYPE_p_wxPageSetupDialog swig_types[111]
2574 #define SWIGTYPE_p_wxPageSetupDialogData swig_types[112]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[113]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[114]
2577 #define SWIGTYPE_p_wxPanel swig_types[115]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[116]
2579 #define SWIGTYPE_p_wxPasswordEntryDialog swig_types[117]
2580 #define SWIGTYPE_p_wxPoint swig_types[118]
2581 #define SWIGTYPE_p_wxPopupWindow swig_types[119]
2582 #define SWIGTYPE_p_wxPreviewCanvas swig_types[120]
2583 #define SWIGTYPE_p_wxPreviewControlBar swig_types[121]
2584 #define SWIGTYPE_p_wxPreviewFrame swig_types[122]
2585 #define SWIGTYPE_p_wxPrintData swig_types[123]
2586 #define SWIGTYPE_p_wxPrintDialog swig_types[124]
2587 #define SWIGTYPE_p_wxPrintDialogData swig_types[125]
2588 #define SWIGTYPE_p_wxPrintPreview swig_types[126]
2589 #define SWIGTYPE_p_wxPrinter swig_types[127]
2590 #define SWIGTYPE_p_wxProgressDialog swig_types[128]
2591 #define SWIGTYPE_p_wxPyApp swig_types[129]
2592 #define SWIGTYPE_p_wxPyCommandEvent swig_types[130]
2593 #define SWIGTYPE_p_wxPyEvent swig_types[131]
2594 #define SWIGTYPE_p_wxPyGridCellAttrProvider swig_types[132]
2595 #define SWIGTYPE_p_wxPyGridCellEditor swig_types[133]
2596 #define SWIGTYPE_p_wxPyGridCellRenderer swig_types[134]
2597 #define SWIGTYPE_p_wxPyGridTableBase swig_types[135]
2598 #define SWIGTYPE_p_wxPyHtmlListBox swig_types[136]
2599 #define SWIGTYPE_p_wxPyImageHandler swig_types[137]
2600 #define SWIGTYPE_p_wxPyPanel swig_types[138]
2601 #define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[139]
2602 #define SWIGTYPE_p_wxPyPreviewControlBar swig_types[140]
2603 #define SWIGTYPE_p_wxPyPreviewFrame swig_types[141]
2604 #define SWIGTYPE_p_wxPyPrintPreview swig_types[142]
2605 #define SWIGTYPE_p_wxPyPrintout swig_types[143]
2606 #define SWIGTYPE_p_wxPyScrolledWindow swig_types[144]
2607 #define SWIGTYPE_p_wxPySizer swig_types[145]
2608 #define SWIGTYPE_p_wxPyTaskBarIcon swig_types[146]
2609 #define SWIGTYPE_p_wxPyVListBox swig_types[147]
2610 #define SWIGTYPE_p_wxPyVScrolledWindow swig_types[148]
2611 #define SWIGTYPE_p_wxPyValidator swig_types[149]
2612 #define SWIGTYPE_p_wxPyWindow swig_types[150]
2613 #define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[151]
2614 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[152]
2615 #define SWIGTYPE_p_wxRect swig_types[153]
2616 #define SWIGTYPE_p_wxSashEvent swig_types[154]
2617 #define SWIGTYPE_p_wxSashLayoutWindow swig_types[155]
2618 #define SWIGTYPE_p_wxSashWindow swig_types[156]
2619 #define SWIGTYPE_p_wxScrollEvent swig_types[157]
2620 #define SWIGTYPE_p_wxScrollWinEvent swig_types[158]
2621 #define SWIGTYPE_p_wxScrolledWindow swig_types[159]
2622 #define SWIGTYPE_p_wxSetCursorEvent swig_types[160]
2623 #define SWIGTYPE_p_wxShowEvent swig_types[161]
2624 #define SWIGTYPE_p_wxSingleChoiceDialog swig_types[162]
2625 #define SWIGTYPE_p_wxSizeEvent swig_types[163]
2626 #define SWIGTYPE_p_wxSizer swig_types[164]
2627 #define SWIGTYPE_p_wxSizerItem swig_types[165]
2628 #define SWIGTYPE_p_wxSplashScreen swig_types[166]
2629 #define SWIGTYPE_p_wxSplashScreenWindow swig_types[167]
2630 #define SWIGTYPE_p_wxSplitterEvent swig_types[168]
2631 #define SWIGTYPE_p_wxSplitterWindow swig_types[169]
2632 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[170]
2633 #define SWIGTYPE_p_wxStatusBar swig_types[171]
2634 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[172]
2635 #define SWIGTYPE_p_wxString swig_types[173]
2636 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[174]
2637 #define SWIGTYPE_p_wxTIFFHandler swig_types[175]
2638 #define SWIGTYPE_p_wxTaskBarIconEvent swig_types[176]
2639 #define SWIGTYPE_p_wxTextEntryDialog swig_types[177]
2640 #define SWIGTYPE_p_wxTipWindow swig_types[178]
2641 #define SWIGTYPE_p_wxTopLevelWindow swig_types[179]
2642 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[180]
2643 #define SWIGTYPE_p_wxValidator swig_types[181]
2644 #define SWIGTYPE_p_wxVisualAttributes swig_types[182]
2645 #define SWIGTYPE_p_wxWindow swig_types[183]
2646 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[184]
2647 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[185]
2648 #define SWIGTYPE_p_wxXPMHandler swig_types[186]
2649 static swig_type_info *swig_types[188];
2650 static swig_module_info swig_module = {swig_types, 187, 0, 0, 0, 0};
2651 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2652 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2653
2654 /* -------- TYPES TABLE (END) -------- */
2655
2656 #if (PY_VERSION_HEX <= 0x02000000)
2657 # if !defined(SWIG_PYTHON_CLASSIC)
2658 # error "This python version requires to use swig with the '-classic' option"
2659 # endif
2660 #endif
2661 #if (PY_VERSION_HEX <= 0x02020000)
2662 # error "This python version requires to use swig with the '-nomodern' option"
2663 #endif
2664 #if (PY_VERSION_HEX <= 0x02020000)
2665 # error "This python version requires to use swig with the '-nomodernargs' option"
2666 #endif
2667 #ifndef METH_O
2668 # error "This python version requires to use swig with the '-nofastunpack' option"
2669 #endif
2670
2671 /*-----------------------------------------------
2672 @(target):= _grid.so
2673 ------------------------------------------------*/
2674 #define SWIG_init init_grid
2675
2676 #define SWIG_name "_grid"
2677
2678 #define SWIGVERSION 0x010329
2679
2680
2681 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2682 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2683
2684
2685 #include <stdexcept>
2686
2687
2688 namespace swig {
2689 class PyObject_ptr {
2690 protected:
2691 PyObject *_obj;
2692
2693 public:
2694 PyObject_ptr() :_obj(0)
2695 {
2696 }
2697
2698 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2699 {
2700 Py_XINCREF(_obj);
2701 }
2702
2703 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2704 {
2705 if (initial_ref) Py_XINCREF(_obj);
2706 }
2707
2708 PyObject_ptr & operator=(const PyObject_ptr& item)
2709 {
2710 Py_XINCREF(item._obj);
2711 Py_XDECREF(_obj);
2712 _obj = item._obj;
2713 return *this;
2714 }
2715
2716 ~PyObject_ptr()
2717 {
2718 Py_XDECREF(_obj);
2719 }
2720
2721 operator PyObject *() const
2722 {
2723 return _obj;
2724 }
2725
2726 PyObject *operator->() const
2727 {
2728 return _obj;
2729 }
2730 };
2731 }
2732
2733
2734 namespace swig {
2735 struct PyObject_var : PyObject_ptr {
2736 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2737
2738 PyObject_var & operator = (PyObject* obj)
2739 {
2740 Py_XDECREF(_obj);
2741 _obj = obj;
2742 return *this;
2743 }
2744 };
2745 }
2746
2747
2748 #include "wx/wxPython/wxPython.h"
2749 #include "wx/wxPython/pyclasses.h"
2750 #include "wx/wxPython/printfw.h"
2751
2752 #include <wx/grid.h>
2753 #include <wx/generic/gridctrl.h>
2754
2755
2756 static const wxString wxPyEmptyString(wxEmptyString);
2757 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2758 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2759
2760
2761 #define wxPyMake_TEMPLATE(TYPE) \
2762 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
2763 PyObject* target = NULL; \
2764 if (source) { \
2765 /* Check if there is already a pointer to a Python object in the \
2766 OOR data that we can use. */ \
2767 wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
2768 if (data) { \
2769 target = data->m_obj; \
2770 if (target) \
2771 Py_INCREF(target); \
2772 } \
2773 /* Otherwise make a new wrapper for it the old fashioned way and \
2774 give it the OOR treatment */ \
2775 if (! target) { \
2776 target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
2777 if (target) \
2778 source->SetClientObject(new wxPyOORClientData(target)); \
2779 } \
2780 } else { /* source was NULL so return None. */ \
2781 Py_INCREF(Py_None); target = Py_None; \
2782 } \
2783 return target; \
2784 } \
2785
2786
2787 wxPyMake_TEMPLATE(wxGridCellRenderer)
2788 wxPyMake_TEMPLATE(wxGridCellEditor)
2789 wxPyMake_TEMPLATE(wxGridCellAttr)
2790 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
2791 wxPyMake_TEMPLATE(wxGridTableBase)
2792
2793
2794
2795 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
2796 wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
2797 wxGridCellAttr* rval = NULL; \
2798 bool found; \
2799 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2800 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2801 PyObject* ro; \
2802 wxGridCellAttr* ptr; \
2803 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
2804 if (ro) { \
2805 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
2806 rval = ptr; \
2807 Py_DECREF(ro); \
2808 } \
2809 } \
2810 wxPyEndBlockThreads(blocked); \
2811 if (! found) \
2812 rval = PCLASS::CBNAME(a, b, c); \
2813 return rval; \
2814 }
2815
2816
2817 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
2818 void CBNAME(wxGridCellAttr *attr, int a, int b) { \
2819 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2820 bool found; \
2821 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2822 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2823 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
2824 Py_DECREF(obj); \
2825 } \
2826 wxPyEndBlockThreads(blocked); \
2827 if (! found) \
2828 PCLASS::CBNAME(attr, a, b); \
2829 }
2830
2831
2832
2833 #define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
2834 void CBNAME(wxGridCellAttr *attr, int val) { \
2835 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2836 bool found; \
2837 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2838 PyObject* obj = wxPyMake_wxGridCellAttr(attr,false); \
2839 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
2840 Py_DECREF(obj); \
2841 } \
2842 wxPyEndBlockThreads(blocked); \
2843 if (! found) \
2844 PCLASS::CBNAME(attr, val); \
2845 }
2846
2847
2848
2849 #define PYCALLBACK_INT__pure(CBNAME) \
2850 int CBNAME() { \
2851 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2852 int rval = 0; \
2853 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2854 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2855 wxPyEndBlockThreads(blocked); \
2856 return rval; \
2857 }
2858
2859
2860
2861 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
2862 bool CBNAME(int a, int b) { \
2863 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2864 bool rval = 0; \
2865 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
2866 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
2867 wxPyEndBlockThreads(blocked); \
2868 return rval; \
2869 }
2870
2871
2872 #define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
2873 wxString CBNAME(int a, int b) { \
2874 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2875 wxString rval; \
2876 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2877 PyObject* ro; \
2878 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2879 if (ro) { \
2880 rval = Py2wxString(ro); \
2881 Py_DECREF(ro); \
2882 } \
2883 } \
2884 wxPyEndBlockThreads(blocked); \
2885 return rval; \
2886 }
2887
2888
2889 #define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
2890 void CBNAME(int a, int b, const wxString& c) { \
2891 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2892 if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
2893 PyObject* s = wx2PyString(c); \
2894 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2895 Py_DECREF(s); \
2896 } \
2897 wxPyEndBlockThreads(blocked); \
2898 }
2899
2900
2901 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
2902 wxString CBNAME(int a, int b) { \
2903 bool found; \
2904 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2905 wxString rval; \
2906 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2907 PyObject* ro; \
2908 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2909 if (ro) { \
2910 rval = Py2wxString(ro); \
2911 Py_DECREF(ro); \
2912 } \
2913 } \
2914 wxPyEndBlockThreads(blocked); \
2915 if (! found) \
2916 rval = PCLASS::CBNAME(a, b); \
2917 return rval; \
2918 }
2919
2920
2921 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
2922 bool CBNAME(int a, int b, const wxString& c) { \
2923 bool rval = 0; \
2924 bool found; \
2925 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2926 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2927 PyObject* s = wx2PyString(c); \
2928 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
2929 Py_DECREF(s); \
2930 } \
2931 wxPyEndBlockThreads(blocked); \
2932 if (! found) \
2933 rval = PCLASS::CBNAME(a,b,c); \
2934 return rval; \
2935 }
2936
2937
2938
2939
2940 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
2941 long CBNAME(int a, int b) { \
2942 long rval; \
2943 bool found; \
2944 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2945 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2946 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2947 wxPyEndBlockThreads(blocked); \
2948 if (! found) \
2949 rval = PCLASS::CBNAME(a,b); \
2950 return rval; \
2951 }
2952
2953
2954 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
2955 bool CBNAME(int a, int b) { \
2956 bool rval = 0; \
2957 bool found; \
2958 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2959 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2960 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
2961 wxPyEndBlockThreads(blocked); \
2962 if (! found) \
2963 rval = PCLASS::CBNAME(a,b); \
2964 return rval; \
2965 }
2966
2967
2968
2969 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
2970 double CBNAME(int a, int b) { \
2971 bool found; \
2972 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2973 double rval; \
2974 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
2975 PyObject* ro; \
2976 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
2977 if (ro) { \
2978 PyObject* str = PyObject_Str(ro); \
2979 rval = PyFloat_AsDouble(str); \
2980 Py_DECREF(ro); Py_DECREF(str); \
2981 } \
2982 } \
2983 wxPyEndBlockThreads(blocked); \
2984 if (! found) \
2985 rval = PCLASS::CBNAME(a, b); \
2986 return rval; \
2987 }
2988
2989
2990
2991 #define PYCALLBACK__(PCLASS, CBNAME) \
2992 void CBNAME() { \
2993 bool found; \
2994 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
2995 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
2996 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
2997 wxPyEndBlockThreads(blocked); \
2998 if (! found) \
2999 PCLASS::CBNAME(); \
3000 }
3001
3002
3003
3004 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
3005 bool CBNAME(size_t a, size_t b) { \
3006 bool rval = 0; \
3007 bool found; \
3008 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3009 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3010 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3011 wxPyEndBlockThreads(blocked); \
3012 if (! found) \
3013 rval = PCLASS::CBNAME(a,b); \
3014 return rval; \
3015 }
3016
3017
3018
3019 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
3020 bool CBNAME(size_t a) { \
3021 bool rval = 0; \
3022 bool found; \
3023 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3024 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3025 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
3026 wxPyEndBlockThreads(blocked); \
3027 if (! found) \
3028 rval = PCLASS::CBNAME(a); \
3029 return rval; \
3030 }
3031
3032
3033 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
3034 wxString CBNAME(int a) { \
3035 bool found; \
3036 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3037 wxString rval; \
3038 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3039 PyObject* ro; \
3040 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
3041 if (ro) { \
3042 rval = Py2wxString(ro); \
3043 Py_DECREF(ro); \
3044 } \
3045 } \
3046 wxPyEndBlockThreads(blocked); \
3047 if (! found) \
3048 rval = PCLASS::CBNAME(a); \
3049 return rval; \
3050 }
3051
3052
3053 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
3054 void CBNAME(int a, const wxString& c) { \
3055 bool found; \
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3057 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) { \
3058 PyObject* s = wx2PyString(c); \
3059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s)); \
3060 Py_DECREF(s); \
3061 } \
3062 wxPyEndBlockThreads(blocked); \
3063 if (! found) \
3064 PCLASS::CBNAME(a,c); \
3065 }
3066
3067
3068
3069
3070 #define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
3071 bool CBNAME() { \
3072 bool rval = 0; \
3073 bool found; \
3074 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3075 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3076 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
3077 wxPyEndBlockThreads(blocked); \
3078 if (! found) \
3079 rval = PCLASS::CBNAME(); \
3080 return rval; \
3081 }
3082
3083
3084
3085 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
3086 void CBNAME(size_t a, int b) { \
3087 bool found; \
3088 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3089 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3090 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
3091 wxPyEndBlockThreads(blocked); \
3092 if (! found) \
3093 PCLASS::CBNAME(a,b); \
3094 }
3095
3096
3097
3098
3099 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
3100 void CBNAME(int a, int b, long c) { \
3101 bool found; \
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3103 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3104 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3105 wxPyEndBlockThreads(blocked); \
3106 if (! found) \
3107 PCLASS::CBNAME(a,b,c); \
3108 }
3109
3110
3111
3112
3113 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
3114 void CBNAME(int a, int b, double c) { \
3115 bool found; \
3116 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3117 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3118 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
3119 wxPyEndBlockThreads(blocked); \
3120 if (! found) \
3121 PCLASS::CBNAME(a,b,c); \
3122 }
3123
3124
3125
3126 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
3127 void CBNAME(int a, int b, bool c) { \
3128 bool found; \
3129 wxPyBlock_t blocked = wxPyBeginBlockThreads(); \
3130 if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) \
3131 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
3132 wxPyEndBlockThreads(blocked); \
3133 if (! found) \
3134 PCLASS::CBNAME(a,b,c); \
3135 }
3136
3137
3138
3139
3140
3141 SWIGINTERN swig_type_info*
3142 SWIG_pchar_descriptor()
3143 {
3144 static int init = 0;
3145 static swig_type_info* info = 0;
3146 if (!init) {
3147 info = SWIG_TypeQuery("_p_char");
3148 init = 1;
3149 }
3150 return info;
3151 }
3152
3153
3154 SWIGINTERNINLINE PyObject *
3155 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3156 {
3157 if (carray) {
3158 if (size > INT_MAX) {
3159 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3160 return pchar_descriptor ?
3161 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3162 } else {
3163 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3164 }
3165 } else {
3166 return SWIG_Py_Void();
3167 }
3168 }
3169
3170
3171 SWIGINTERNINLINE PyObject *
3172 SWIG_FromCharPtr(const char *cptr)
3173 {
3174 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3175 }
3176
3177
3178 #define wxGRID_DEFAULT_NUMBER_ROWS WXGRID_DEFAULT_NUMBER_ROWS
3179 #define wxGRID_DEFAULT_NUMBER_COLS WXGRID_DEFAULT_NUMBER_COLS
3180 #define wxGRID_DEFAULT_ROW_HEIGHT WXGRID_DEFAULT_ROW_HEIGHT
3181 #define wxGRID_DEFAULT_COL_WIDTH WXGRID_DEFAULT_COL_WIDTH
3182 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT WXGRID_DEFAULT_COL_LABEL_HEIGHT
3183 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH WXGRID_DEFAULT_ROW_LABEL_WIDTH
3184 #define wxGRID_LABEL_EDGE_ZONE WXGRID_LABEL_EDGE_ZONE
3185 #define wxGRID_MIN_ROW_HEIGHT WXGRID_MIN_ROW_HEIGHT
3186 #define wxGRID_MIN_COL_WIDTH WXGRID_MIN_COL_WIDTH
3187 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH WXGRID_DEFAULT_SCROLLBAR_WIDTH
3188
3189
3190 #define SWIG_From_long PyInt_FromLong
3191
3192
3193 SWIGINTERNINLINE PyObject *
3194 SWIG_From_int (int value)
3195 {
3196 return SWIG_From_long (value);
3197 }
3198
3199 SWIGINTERN void wxGridCellWorker__setOORInfo(wxGridCellWorker *self,PyObject *_self){
3200 if (!self->GetClientObject())
3201 self->SetClientObject(new wxPyOORClientData(_self));
3202 }
3203 SWIGINTERN void delete_wxGridCellWorker(wxGridCellWorker *self){
3204 }
3205
3206 class wxPyGridCellRenderer : public wxGridCellRenderer
3207 {
3208 public:
3209 wxPyGridCellRenderer() : wxGridCellRenderer() {};
3210
3211 // Implement Python callback aware virtual methods
3212 void Draw(wxGrid& grid, wxGridCellAttr& attr,
3213 wxDC& dc, const wxRect& rect,
3214 int row, int col, bool isSelected) {
3215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3216 if (wxPyCBH_findCallback(m_myInst, "Draw")) {
3217 PyObject* go = wxPyMake_wxObject(&grid,false);
3218 PyObject* dco = wxPyMake_wxObject(&dc,false);
3219 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3220 PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
3221
3222 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
3223 row, col, isSelected));
3224 Py_DECREF(go);
3225 Py_DECREF(ao);
3226 Py_DECREF(dco);
3227 Py_DECREF(ro);
3228 }
3229 wxPyEndBlockThreads(blocked);
3230 }
3231
3232 wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
3233 int row, int col) {
3234 wxSize rval;
3235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3236 if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
3237 PyObject* ro;
3238 wxSize* ptr;
3239 PyObject* go = wxPyMake_wxObject(&grid,false);
3240 PyObject* dco = wxPyMake_wxObject(&dc,false);
3241 PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
3242
3243 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
3244 go, ao, dco,
3245 row, col));
3246 Py_DECREF(go);
3247 Py_DECREF(ao);
3248 Py_DECREF(dco);
3249
3250 if (ro) {
3251 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
3252 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
3253 rval = *ptr;
3254 }
3255 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
3256 PyObject* o1 = PySequence_GetItem(ro, 0);
3257 PyObject* o2 = PySequence_GetItem(ro, 1);
3258 if (PyNumber_Check(o1) && PyNumber_Check(o2))
3259 rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
3260 else
3261 PyErr_SetString(PyExc_TypeError, errmsg);
3262 Py_DECREF(o1);
3263 Py_DECREF(o2);
3264 }
3265 else {
3266 PyErr_SetString(PyExc_TypeError, errmsg);
3267 }
3268 Py_DECREF(ro);
3269 }
3270 }
3271 wxPyEndBlockThreads(blocked);
3272 return rval;
3273 }
3274
3275
3276 wxGridCellRenderer *Clone() const {
3277 wxGridCellRenderer* rval = NULL;
3278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3279 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3280 PyObject* ro;
3281 wxGridCellRenderer* ptr;
3282 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3283 if (ro) {
3284 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
3285 rval = ptr;
3286 Py_DECREF(ro);
3287 }
3288 }
3289 wxPyEndBlockThreads(blocked);
3290 return rval;
3291 }
3292
3293 DEC_PYCALLBACK__STRING(SetParameters);
3294
3295 PYPRIVATE;
3296 };
3297
3298 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
3299
3300
3301
3302 #include <limits.h>
3303 #ifndef LLONG_MIN
3304 # define LLONG_MIN LONG_LONG_MIN
3305 #endif
3306 #ifndef LLONG_MAX
3307 # define LLONG_MAX LONG_LONG_MAX
3308 #endif
3309 #ifndef ULLONG_MAX
3310 # define ULLONG_MAX ULONG_LONG_MAX
3311 #endif
3312
3313
3314 SWIGINTERN int
3315 SWIG_AsVal_long (PyObject* obj, long* val)
3316 {
3317 if (PyNumber_Check(obj)) {
3318 if (val) *val = PyInt_AsLong(obj);
3319 return SWIG_OK;
3320 }
3321 return SWIG_TypeError;
3322 }
3323
3324
3325 SWIGINTERN int
3326 SWIG_AsVal_int (PyObject * obj, int *val)
3327 {
3328 long v;
3329 int res = SWIG_AsVal_long (obj, &v);
3330 if (SWIG_IsOK(res)) {
3331 if ((v < INT_MIN || v > INT_MAX)) {
3332 return SWIG_OverflowError;
3333 } else {
3334 if (val) *val = static_cast< int >(v);
3335 }
3336 }
3337 return res;
3338 }
3339
3340
3341 SWIGINTERN int
3342 SWIG_AsVal_bool (PyObject *obj, bool *val)
3343 {
3344 if (obj == Py_True) {
3345 if (val) *val = true;
3346 return SWIG_OK;
3347 } else if (obj == Py_False) {
3348 if (val) *val = false;
3349 return SWIG_OK;
3350 } else {
3351 long v = 0;
3352 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3353 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3354 return res;
3355 }
3356 }
3357
3358
3359 class wxPyGridCellEditor : public wxGridCellEditor
3360 {
3361 public:
3362 wxPyGridCellEditor() : wxGridCellEditor() {}
3363
3364 void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
3365 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3366 if (wxPyCBH_findCallback(m_myInst, "Create")) {
3367 PyObject* po = wxPyMake_wxObject(parent,false);
3368 PyObject* eo = wxPyMake_wxObject(evtHandler,false);
3369
3370 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
3371 Py_DECREF(po);
3372 Py_DECREF(eo);
3373 }
3374 wxPyEndBlockThreads(blocked);
3375 }
3376
3377
3378 void BeginEdit(int row, int col, wxGrid* grid) {
3379 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3380 if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
3381 PyObject* go = wxPyMake_wxObject(grid,false);
3382 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3383 Py_DECREF(go);
3384 }
3385 wxPyEndBlockThreads(blocked);
3386 }
3387
3388
3389 bool EndEdit(int row, int col, wxGrid* grid) {
3390 bool rv = false;
3391 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3392 if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
3393 PyObject* go = wxPyMake_wxObject(grid,false);
3394 rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
3395 Py_DECREF(go);
3396 }
3397 wxPyEndBlockThreads(blocked);
3398 return rv;
3399 }
3400
3401
3402 wxGridCellEditor* Clone() const {
3403 wxGridCellEditor* rval = NULL;
3404 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3405 if (wxPyCBH_findCallback(m_myInst, "Clone")) {
3406 PyObject* ro;
3407 wxGridCellEditor* ptr;
3408 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3409 if (ro) {
3410 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
3411 rval = ptr;
3412 Py_DECREF(ro);
3413 }
3414 }
3415 wxPyEndBlockThreads(blocked);
3416 return rval;
3417 }
3418
3419
3420 void Show(bool show, wxGridCellAttr *attr) {
3421 bool found;
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
3424 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3425 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
3426 Py_DECREF(ao);
3427 }
3428 wxPyEndBlockThreads(blocked);
3429 if (! found)
3430 wxGridCellEditor::Show(show, attr);
3431 }
3432
3433
3434 void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
3435 bool found;
3436 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3437 if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
3438 PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
3439 PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
3440
3441 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
3442
3443 Py_DECREF(ro);
3444 Py_DECREF(ao);
3445 }
3446 wxPyEndBlockThreads(blocked);
3447 if (! found)
3448 wxGridCellEditor::PaintBackground(rectCell, attr);
3449 }
3450
3451
3452 DEC_PYCALLBACK___pure(Reset);
3453 DEC_PYCALLBACK__constany(SetSize, wxRect);
3454 DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
3455 DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
3456 DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
3457 DEC_PYCALLBACK__(StartingClick);
3458 DEC_PYCALLBACK__(Destroy);
3459 DEC_PYCALLBACK__STRING(SetParameters);
3460 DEC_PYCALLBACK_STRING__constpure(GetValue);
3461
3462 PYPRIVATE;
3463 };
3464
3465
3466 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
3467 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
3468 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
3469 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
3470 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
3471 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
3472 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
3473 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
3474 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
3475
3476
3477 SWIGINTERN void wxGridCellAttr__setOORInfo(wxGridCellAttr *self,PyObject *_self){
3478 if (!self->GetClientObject())
3479 self->SetClientObject(new wxPyOORClientData(_self));
3480 }
3481 SWIGINTERN void delete_wxGridCellAttr(wxGridCellAttr *self){
3482 }
3483 SWIGINTERN void wxGridCellAttrProvider__setOORInfo(wxGridCellAttrProvider *self,PyObject *_self){
3484 if (!self->GetClientObject())
3485 self->SetClientObject(new wxPyOORClientData(_self));
3486 }
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3490 {
3491 long v = 0;
3492 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3493 return SWIG_TypeError;
3494 }
3495 else if (val)
3496 *val = (unsigned long)v;
3497 return SWIG_OK;
3498 }
3499
3500
3501 SWIGINTERNINLINE int
3502 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3503 {
3504 unsigned long v;
3505 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3506 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3507 return res;
3508 }
3509
3510
3511 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
3512 {
3513 public:
3514 wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
3515
3516 PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
3517 PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
3518 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
3519 PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
3520
3521 PYPRIVATE;
3522 };
3523
3524 SWIGINTERN void wxGridTableBase__setOORInfo(wxGridTableBase *self,PyObject *_self){
3525 if (!self->GetClientObject())
3526 self->SetClientObject(new wxPyOORClientData(_self));
3527 }
3528
3529 #define SWIG_From_double PyFloat_FromDouble
3530
3531
3532 SWIGINTERN int
3533 SWIG_AsVal_double (PyObject *obj, double* val)
3534 {
3535 if (PyNumber_Check(obj)) {
3536 if (val) *val = PyFloat_AsDouble(obj);
3537 return SWIG_OK;
3538 }
3539 return SWIG_TypeError;
3540 }
3541
3542
3543 class wxPyGridTableBase : public wxGridTableBase
3544 {
3545 public:
3546 wxPyGridTableBase() : wxGridTableBase() {}
3547
3548 PYCALLBACK_INT__pure(GetNumberRows);
3549 PYCALLBACK_INT__pure(GetNumberCols);
3550 PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
3551 PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
3552 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
3553 PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
3554 PYCALLBACK__(wxGridTableBase, Clear);
3555 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
3556 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
3557 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
3558 PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
3559 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
3560 PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
3561 PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
3562 PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
3563 PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
3564 PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
3565 PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
3566 PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
3567 PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
3568 PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
3569 PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
3570
3571
3572 wxString GetValue(int row, int col) {
3573 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3574 wxString rval;
3575 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3576 PyObject* ro;
3577 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
3578 if (ro) {
3579 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
3580 PyObject* old = ro;
3581 ro = PyObject_Str(ro);
3582 Py_DECREF(old);
3583 }
3584 rval = Py2wxString(ro);
3585 Py_DECREF(ro);
3586 }
3587 }
3588 wxPyEndBlockThreads(blocked);
3589 return rval;
3590 }
3591
3592 void SetValue(int row, int col, const wxString& val) {
3593 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3594 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3595 PyObject* s = wx2PyString(val);
3596 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
3597 Py_DECREF(s);
3598 }
3599 wxPyEndBlockThreads(blocked);
3600 }
3601
3602
3603 // Map the Get/Set methods for the standard non-string types to
3604 // the GetValue and SetValue python methods.
3605 long GetValueAsLong( int row, int col ) {
3606 long rval = 0;
3607 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3608 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3609 PyObject* ro;
3610 PyObject* num;
3611 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3612 if (ro && PyNumber_Check(ro)) {
3613 num = PyNumber_Int(ro);
3614 if (num) {
3615 rval = PyInt_AsLong(num);
3616 Py_DECREF(num);
3617 }
3618 Py_DECREF(ro);
3619 }
3620 }
3621 wxPyEndBlockThreads(blocked);
3622 return rval;
3623 }
3624
3625 double GetValueAsDouble( int row, int col ) {
3626 double rval = 0.0;
3627 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3628 if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
3629 PyObject* ro;
3630 PyObject* num;
3631 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
3632 if (ro && PyNumber_Check(ro)) {
3633 num = PyNumber_Float(ro);
3634 if (num) {
3635 rval = PyFloat_AsDouble(num);
3636 Py_DECREF(num);
3637 }
3638 Py_DECREF(ro);
3639 }
3640 }
3641 wxPyEndBlockThreads(blocked);
3642 return rval;
3643 }
3644
3645 bool GetValueAsBool( int row, int col ) {
3646 return (bool)GetValueAsLong(row, col);
3647 }
3648
3649 void SetValueAsLong( int row, int col, long value ) {
3650 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3651 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3652 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
3653 }
3654 wxPyEndBlockThreads(blocked);
3655 }
3656
3657 void SetValueAsDouble( int row, int col, double value ) {
3658 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3659 if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
3660 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
3661 }
3662 wxPyEndBlockThreads(blocked);
3663 }
3664
3665 void SetValueAsBool( int row, int col, bool value ) {
3666 SetValueAsLong( row, col, (long)value );
3667 }
3668
3669
3670 PYPRIVATE;
3671 };
3672
3673 SWIGINTERN void wxPyGridTableBase_Destroy(wxPyGridTableBase *self){ delete self; }
3674
3675 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
3676
3677 if (source == Py_None) {
3678 **obj = wxGridCellCoords(-1,-1);
3679 return true;
3680 }
3681
3682 // If source is an object instance then it may already be the right type
3683 if (wxPySwigInstance_Check(source)) {
3684 wxGridCellCoords* ptr;
3685 if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3686 goto error;
3687 *obj = ptr;
3688 return true;
3689 }
3690 // otherwise a 2-tuple of integers is expected
3691 else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
3692 PyObject* o1 = PySequence_GetItem(source, 0);
3693 PyObject* o2 = PySequence_GetItem(source, 1);
3694 if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
3695 Py_DECREF(o1);
3696 Py_DECREF(o2);
3697 goto error;
3698 }
3699 **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
3700 Py_DECREF(o1);
3701 Py_DECREF(o2);
3702 return true;
3703 }
3704
3705 error:
3706 PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
3707 return false;
3708 }
3709
3710
3711 bool wxGridCellCoords_typecheck(PyObject* source) {
3712 void* ptr;
3713
3714 if (wxPySwigInstance_Check(source) &&
3715 wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
3716 return true;
3717
3718 PyErr_Clear();
3719 if (PySequence_Check(source) && PySequence_Length(source) == 2)
3720 return true;
3721
3722 return false;
3723 }
3724
3725
3726 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
3727 {
3728 PyObject* list = PyList_New(0);
3729 size_t idx;
3730 for (idx = 0; idx < source.GetCount(); idx += 1) {
3731 wxGridCellCoords& coord = source.Item(idx);
3732 PyObject* tup = PyTuple_New(2);
3733 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
3734 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
3735 PyList_Append(list, tup);
3736 Py_DECREF(tup);
3737 }
3738 return list;
3739 }
3740
3741 SWIGINTERN bool wxGridCellCoords___eq__(wxGridCellCoords *self,PyObject *other){
3742 wxGridCellCoords temp, *obj = &temp;
3743 if ( other == Py_None ) return false;
3744 if ( ! wxGridCellCoords_helper(other, &obj) ) {
3745 PyErr_Clear();
3746 return false;
3747 }
3748 return self->operator==(*obj);
3749 }
3750 SWIGINTERN bool wxGridCellCoords___ne__(wxGridCellCoords *self,PyObject *other){
3751 wxGridCellCoords temp, *obj = &temp;
3752 if ( other == Py_None ) return true;
3753 if ( ! wxGridCellCoords_helper(other, &obj)) {
3754 PyErr_Clear();
3755 return true;
3756 }
3757 return self->operator!=(*obj);
3758 }
3759 SWIGINTERN PyObject *wxGridCellCoords_Get(wxGridCellCoords *self){
3760 PyObject* tup = PyTuple_New(2);
3761 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3762 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3763 return tup;
3764 }
3765
3766 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
3767
3768 SWIGINTERN wxGridCellCoords wxGrid_XYToCell(wxGrid *self,int x,int y){
3769 wxGridCellCoords rv;
3770 self->XYToCell(x, y, rv);
3771 return rv;
3772 }
3773 #ifdef __cplusplus
3774 extern "C" {
3775 #endif
3776 SWIGINTERN int GridNoCellCoords_set(PyObject *) {
3777 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellCoords is read-only.");
3778 return 1;
3779 }
3780
3781
3782 SWIGINTERN PyObject *GridNoCellCoords_get(void) {
3783 PyObject *pyobj = 0;
3784
3785 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellCoords), SWIGTYPE_p_wxGridCellCoords, 0 );
3786 return pyobj;
3787 }
3788
3789
3790 SWIGINTERN int GridNoCellRect_set(PyObject *) {
3791 SWIG_Error(SWIG_AttributeError,"Variable GridNoCellRect is read-only.");
3792 return 1;
3793 }
3794
3795
3796 SWIGINTERN PyObject *GridNoCellRect_get(void) {
3797 PyObject *pyobj = 0;
3798
3799 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxGridNoCellRect), SWIGTYPE_p_wxRect, 0 );
3800 return pyobj;
3801 }
3802
3803
3804 SWIGINTERN PyObject *_wrap_GridCellWorker__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3805 PyObject *resultobj = 0;
3806 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3807 PyObject *arg2 = (PyObject *) 0 ;
3808 void *argp1 = 0 ;
3809 int res1 = 0 ;
3810 PyObject * obj0 = 0 ;
3811 PyObject * obj1 = 0 ;
3812 char * kwnames[] = {
3813 (char *) "self",(char *) "_self", NULL
3814 };
3815
3816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
3817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3818 if (!SWIG_IsOK(res1)) {
3819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3820 }
3821 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3822 arg2 = obj1;
3823 {
3824 PyThreadState* __tstate = wxPyBeginAllowThreads();
3825 wxGridCellWorker__setOORInfo(arg1,arg2);
3826 wxPyEndAllowThreads(__tstate);
3827 if (PyErr_Occurred()) SWIG_fail;
3828 }
3829 resultobj = SWIG_Py_Void();
3830 return resultobj;
3831 fail:
3832 return NULL;
3833 }
3834
3835
3836 SWIGINTERN PyObject *_wrap_delete_GridCellWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3837 PyObject *resultobj = 0;
3838 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3839 void *argp1 = 0 ;
3840 int res1 = 0 ;
3841 PyObject *swig_obj[1] ;
3842
3843 if (!args) SWIG_fail;
3844 swig_obj[0] = args;
3845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, SWIG_POINTER_DISOWN | 0 );
3846 if (!SWIG_IsOK(res1)) {
3847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellWorker" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3848 }
3849 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3850 {
3851 PyThreadState* __tstate = wxPyBeginAllowThreads();
3852 delete_wxGridCellWorker(arg1);
3853
3854 wxPyEndAllowThreads(__tstate);
3855 if (PyErr_Occurred()) SWIG_fail;
3856 }
3857 resultobj = SWIG_Py_Void();
3858 return resultobj;
3859 fail:
3860 return NULL;
3861 }
3862
3863
3864 SWIGINTERN PyObject *_wrap_GridCellWorker_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3865 PyObject *resultobj = 0;
3866 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3867 wxString *arg2 = 0 ;
3868 void *argp1 = 0 ;
3869 int res1 = 0 ;
3870 bool temp2 = false ;
3871 PyObject * obj0 = 0 ;
3872 PyObject * obj1 = 0 ;
3873 char * kwnames[] = {
3874 (char *) "self",(char *) "params", NULL
3875 };
3876
3877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellWorker_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
3878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3879 if (!SWIG_IsOK(res1)) {
3880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_SetParameters" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3881 }
3882 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3883 {
3884 arg2 = wxString_in_helper(obj1);
3885 if (arg2 == NULL) SWIG_fail;
3886 temp2 = true;
3887 }
3888 {
3889 PyThreadState* __tstate = wxPyBeginAllowThreads();
3890 (arg1)->SetParameters((wxString const &)*arg2);
3891 wxPyEndAllowThreads(__tstate);
3892 if (PyErr_Occurred()) SWIG_fail;
3893 }
3894 resultobj = SWIG_Py_Void();
3895 {
3896 if (temp2)
3897 delete arg2;
3898 }
3899 return resultobj;
3900 fail:
3901 {
3902 if (temp2)
3903 delete arg2;
3904 }
3905 return NULL;
3906 }
3907
3908
3909 SWIGINTERN PyObject *_wrap_GridCellWorker_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3910 PyObject *resultobj = 0;
3911 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3912 void *argp1 = 0 ;
3913 int res1 = 0 ;
3914 PyObject *swig_obj[1] ;
3915
3916 if (!args) SWIG_fail;
3917 swig_obj[0] = args;
3918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3919 if (!SWIG_IsOK(res1)) {
3920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_IncRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3921 }
3922 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3923 {
3924 PyThreadState* __tstate = wxPyBeginAllowThreads();
3925 (arg1)->IncRef();
3926 wxPyEndAllowThreads(__tstate);
3927 if (PyErr_Occurred()) SWIG_fail;
3928 }
3929 resultobj = SWIG_Py_Void();
3930 return resultobj;
3931 fail:
3932 return NULL;
3933 }
3934
3935
3936 SWIGINTERN PyObject *_wrap_GridCellWorker_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3937 PyObject *resultobj = 0;
3938 wxGridCellWorker *arg1 = (wxGridCellWorker *) 0 ;
3939 void *argp1 = 0 ;
3940 int res1 = 0 ;
3941 PyObject *swig_obj[1] ;
3942
3943 if (!args) SWIG_fail;
3944 swig_obj[0] = args;
3945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellWorker, 0 | 0 );
3946 if (!SWIG_IsOK(res1)) {
3947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellWorker_DecRef" "', expected argument " "1"" of type '" "wxGridCellWorker *""'");
3948 }
3949 arg1 = reinterpret_cast< wxGridCellWorker * >(argp1);
3950 {
3951 PyThreadState* __tstate = wxPyBeginAllowThreads();
3952 (arg1)->DecRef();
3953 wxPyEndAllowThreads(__tstate);
3954 if (PyErr_Occurred()) SWIG_fail;
3955 }
3956 resultobj = SWIG_Py_Void();
3957 return resultobj;
3958 fail:
3959 return NULL;
3960 }
3961
3962
3963 SWIGINTERN PyObject *GridCellWorker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3964 PyObject *obj;
3965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3966 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellWorker, SWIG_NewClientData(obj));
3967 return SWIG_Py_Void();
3968 }
3969
3970 SWIGINTERN PyObject *GridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3971 PyObject *obj;
3972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3973 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellRenderer, SWIG_NewClientData(obj));
3974 return SWIG_Py_Void();
3975 }
3976
3977 SWIGINTERN PyObject *_wrap_new_PyGridCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3978 PyObject *resultobj = 0;
3979 wxPyGridCellRenderer *result = 0 ;
3980
3981 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellRenderer",0,0,0)) SWIG_fail;
3982 {
3983 PyThreadState* __tstate = wxPyBeginAllowThreads();
3984 result = (wxPyGridCellRenderer *)new wxPyGridCellRenderer();
3985 wxPyEndAllowThreads(__tstate);
3986 if (PyErr_Occurred()) SWIG_fail;
3987 }
3988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellRenderer, SWIG_POINTER_NEW | 0 );
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 SWIGINTERN PyObject *_wrap_PyGridCellRenderer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj = 0;
3997 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
3998 PyObject *arg2 = (PyObject *) 0 ;
3999 PyObject *arg3 = (PyObject *) 0 ;
4000 void *argp1 = 0 ;
4001 int res1 = 0 ;
4002 PyObject * obj0 = 0 ;
4003 PyObject * obj1 = 0 ;
4004 PyObject * obj2 = 0 ;
4005 char * kwnames[] = {
4006 (char *) "self",(char *) "self",(char *) "_class", NULL
4007 };
4008
4009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellRenderer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4011 if (!SWIG_IsOK(res1)) {
4012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4013 }
4014 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4015 arg2 = obj1;
4016 arg3 = obj2;
4017 {
4018 PyThreadState* __tstate = wxPyBeginAllowThreads();
4019 (arg1)->_setCallbackInfo(arg2,arg3);
4020 wxPyEndAllowThreads(__tstate);
4021 if (PyErr_Occurred()) SWIG_fail;
4022 }
4023 resultobj = SWIG_Py_Void();
4024 return resultobj;
4025 fail:
4026 return NULL;
4027 }
4028
4029
4030 SWIGINTERN PyObject *_wrap_PyGridCellRenderer_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4031 PyObject *resultobj = 0;
4032 wxPyGridCellRenderer *arg1 = (wxPyGridCellRenderer *) 0 ;
4033 wxString *arg2 = 0 ;
4034 void *argp1 = 0 ;
4035 int res1 = 0 ;
4036 bool temp2 = false ;
4037 PyObject * obj0 = 0 ;
4038 PyObject * obj1 = 0 ;
4039 char * kwnames[] = {
4040 (char *) "self",(char *) "params", NULL
4041 };
4042
4043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellRenderer_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
4044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellRenderer, 0 | 0 );
4045 if (!SWIG_IsOK(res1)) {
4046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellRenderer_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellRenderer *""'");
4047 }
4048 arg1 = reinterpret_cast< wxPyGridCellRenderer * >(argp1);
4049 {
4050 arg2 = wxString_in_helper(obj1);
4051 if (arg2 == NULL) SWIG_fail;
4052 temp2 = true;
4053 }
4054 {
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 (arg1)->SetParameters((wxString const &)*arg2);
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 resultobj = SWIG_Py_Void();
4061 {
4062 if (temp2)
4063 delete arg2;
4064 }
4065 return resultobj;
4066 fail:
4067 {
4068 if (temp2)
4069 delete arg2;
4070 }
4071 return NULL;
4072 }
4073
4074
4075 SWIGINTERN PyObject *PyGridCellRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4076 PyObject *obj;
4077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellRenderer, SWIG_NewClientData(obj));
4079 return SWIG_Py_Void();
4080 }
4081
4082 SWIGINTERN PyObject *PyGridCellRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4083 return SWIG_Python_InitShadowInstance(args);
4084 }
4085
4086 SWIGINTERN PyObject *_wrap_new_GridCellStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4087 PyObject *resultobj = 0;
4088 wxGridCellStringRenderer *result = 0 ;
4089
4090 if (!SWIG_Python_UnpackTuple(args,"new_GridCellStringRenderer",0,0,0)) SWIG_fail;
4091 {
4092 PyThreadState* __tstate = wxPyBeginAllowThreads();
4093 result = (wxGridCellStringRenderer *)new wxGridCellStringRenderer();
4094 wxPyEndAllowThreads(__tstate);
4095 if (PyErr_Occurred()) SWIG_fail;
4096 }
4097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellStringRenderer, SWIG_POINTER_NEW | 0 );
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 SWIGINTERN PyObject *GridCellStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4105 PyObject *obj;
4106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4107 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellStringRenderer, SWIG_NewClientData(obj));
4108 return SWIG_Py_Void();
4109 }
4110
4111 SWIGINTERN PyObject *GridCellStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4112 return SWIG_Python_InitShadowInstance(args);
4113 }
4114
4115 SWIGINTERN PyObject *_wrap_new_GridCellNumberRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4116 PyObject *resultobj = 0;
4117 wxGridCellNumberRenderer *result = 0 ;
4118
4119 if (!SWIG_Python_UnpackTuple(args,"new_GridCellNumberRenderer",0,0,0)) SWIG_fail;
4120 {
4121 PyThreadState* __tstate = wxPyBeginAllowThreads();
4122 result = (wxGridCellNumberRenderer *)new wxGridCellNumberRenderer();
4123 wxPyEndAllowThreads(__tstate);
4124 if (PyErr_Occurred()) SWIG_fail;
4125 }
4126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_POINTER_NEW | 0 );
4127 return resultobj;
4128 fail:
4129 return NULL;
4130 }
4131
4132
4133 SWIGINTERN PyObject *GridCellNumberRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4134 PyObject *obj;
4135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4136 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberRenderer, SWIG_NewClientData(obj));
4137 return SWIG_Py_Void();
4138 }
4139
4140 SWIGINTERN PyObject *GridCellNumberRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4141 return SWIG_Python_InitShadowInstance(args);
4142 }
4143
4144 SWIGINTERN PyObject *_wrap_new_GridCellFloatRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj = 0;
4146 int arg1 = (int) -1 ;
4147 int arg2 = (int) -1 ;
4148 wxGridCellFloatRenderer *result = 0 ;
4149 int val1 ;
4150 int ecode1 = 0 ;
4151 int val2 ;
4152 int ecode2 = 0 ;
4153 PyObject * obj0 = 0 ;
4154 PyObject * obj1 = 0 ;
4155 char * kwnames[] = {
4156 (char *) "width",(char *) "precision", NULL
4157 };
4158
4159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4160 if (obj0) {
4161 ecode1 = SWIG_AsVal_int(obj0, &val1);
4162 if (!SWIG_IsOK(ecode1)) {
4163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatRenderer" "', expected argument " "1"" of type '" "int""'");
4164 }
4165 arg1 = static_cast< int >(val1);
4166 }
4167 if (obj1) {
4168 ecode2 = SWIG_AsVal_int(obj1, &val2);
4169 if (!SWIG_IsOK(ecode2)) {
4170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatRenderer" "', expected argument " "2"" of type '" "int""'");
4171 }
4172 arg2 = static_cast< int >(val2);
4173 }
4174 {
4175 PyThreadState* __tstate = wxPyBeginAllowThreads();
4176 result = (wxGridCellFloatRenderer *)new wxGridCellFloatRenderer(arg1,arg2);
4177 wxPyEndAllowThreads(__tstate);
4178 if (PyErr_Occurred()) SWIG_fail;
4179 }
4180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_POINTER_NEW | 0 );
4181 return resultobj;
4182 fail:
4183 return NULL;
4184 }
4185
4186
4187 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4188 PyObject *resultobj = 0;
4189 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4190 int result;
4191 void *argp1 = 0 ;
4192 int res1 = 0 ;
4193 PyObject *swig_obj[1] ;
4194
4195 if (!args) SWIG_fail;
4196 swig_obj[0] = args;
4197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4198 if (!SWIG_IsOK(res1)) {
4199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4200 }
4201 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetWidth();
4205 wxPyEndAllowThreads(__tstate);
4206 if (PyErr_Occurred()) SWIG_fail;
4207 }
4208 resultobj = SWIG_From_int(static_cast< int >(result));
4209 return resultobj;
4210 fail:
4211 return NULL;
4212 }
4213
4214
4215 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4216 PyObject *resultobj = 0;
4217 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4218 int arg2 ;
4219 void *argp1 = 0 ;
4220 int res1 = 0 ;
4221 int val2 ;
4222 int ecode2 = 0 ;
4223 PyObject * obj0 = 0 ;
4224 PyObject * obj1 = 0 ;
4225 char * kwnames[] = {
4226 (char *) "self",(char *) "width", NULL
4227 };
4228
4229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4231 if (!SWIG_IsOK(res1)) {
4232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4233 }
4234 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4235 ecode2 = SWIG_AsVal_int(obj1, &val2);
4236 if (!SWIG_IsOK(ecode2)) {
4237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetWidth" "', expected argument " "2"" of type '" "int""'");
4238 }
4239 arg2 = static_cast< int >(val2);
4240 {
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 (arg1)->SetWidth(arg2);
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 resultobj = SWIG_Py_Void();
4247 return resultobj;
4248 fail:
4249 return NULL;
4250 }
4251
4252
4253 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_GetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4254 PyObject *resultobj = 0;
4255 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4256 int result;
4257 void *argp1 = 0 ;
4258 int res1 = 0 ;
4259 PyObject *swig_obj[1] ;
4260
4261 if (!args) SWIG_fail;
4262 swig_obj[0] = args;
4263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4264 if (!SWIG_IsOK(res1)) {
4265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_GetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer const *""'");
4266 }
4267 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = (int)((wxGridCellFloatRenderer const *)arg1)->GetPrecision();
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 resultobj = SWIG_From_int(static_cast< int >(result));
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 SWIGINTERN PyObject *_wrap_GridCellFloatRenderer_SetPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj = 0;
4283 wxGridCellFloatRenderer *arg1 = (wxGridCellFloatRenderer *) 0 ;
4284 int arg2 ;
4285 void *argp1 = 0 ;
4286 int res1 = 0 ;
4287 int val2 ;
4288 int ecode2 = 0 ;
4289 PyObject * obj0 = 0 ;
4290 PyObject * obj1 = 0 ;
4291 char * kwnames[] = {
4292 (char *) "self",(char *) "precision", NULL
4293 };
4294
4295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellFloatRenderer_SetPrecision",kwnames,&obj0,&obj1)) SWIG_fail;
4296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellFloatRenderer, 0 | 0 );
4297 if (!SWIG_IsOK(res1)) {
4298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "1"" of type '" "wxGridCellFloatRenderer *""'");
4299 }
4300 arg1 = reinterpret_cast< wxGridCellFloatRenderer * >(argp1);
4301 ecode2 = SWIG_AsVal_int(obj1, &val2);
4302 if (!SWIG_IsOK(ecode2)) {
4303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellFloatRenderer_SetPrecision" "', expected argument " "2"" of type '" "int""'");
4304 }
4305 arg2 = static_cast< int >(val2);
4306 {
4307 PyThreadState* __tstate = wxPyBeginAllowThreads();
4308 (arg1)->SetPrecision(arg2);
4309 wxPyEndAllowThreads(__tstate);
4310 if (PyErr_Occurred()) SWIG_fail;
4311 }
4312 resultobj = SWIG_Py_Void();
4313 return resultobj;
4314 fail:
4315 return NULL;
4316 }
4317
4318
4319 SWIGINTERN PyObject *GridCellFloatRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4320 PyObject *obj;
4321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4322 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatRenderer, SWIG_NewClientData(obj));
4323 return SWIG_Py_Void();
4324 }
4325
4326 SWIGINTERN PyObject *GridCellFloatRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4327 return SWIG_Python_InitShadowInstance(args);
4328 }
4329
4330 SWIGINTERN PyObject *_wrap_new_GridCellBoolRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331 PyObject *resultobj = 0;
4332 wxGridCellBoolRenderer *result = 0 ;
4333
4334 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolRenderer",0,0,0)) SWIG_fail;
4335 {
4336 PyThreadState* __tstate = wxPyBeginAllowThreads();
4337 result = (wxGridCellBoolRenderer *)new wxGridCellBoolRenderer();
4338 wxPyEndAllowThreads(__tstate);
4339 if (PyErr_Occurred()) SWIG_fail;
4340 }
4341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_POINTER_NEW | 0 );
4342 return resultobj;
4343 fail:
4344 return NULL;
4345 }
4346
4347
4348 SWIGINTERN PyObject *GridCellBoolRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4349 PyObject *obj;
4350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4351 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolRenderer, SWIG_NewClientData(obj));
4352 return SWIG_Py_Void();
4353 }
4354
4355 SWIGINTERN PyObject *GridCellBoolRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4356 return SWIG_Python_InitShadowInstance(args);
4357 }
4358
4359 SWIGINTERN PyObject *_wrap_new_GridCellDateTimeRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj = 0;
4361 wxString arg1 = (wxString) wxPyDefaultDateTimeFormat ;
4362 wxString arg2 = (wxString) wxPyDefaultDateTimeFormat ;
4363 wxGridCellDateTimeRenderer *result = 0 ;
4364 PyObject * obj0 = 0 ;
4365 PyObject * obj1 = 0 ;
4366 char * kwnames[] = {
4367 (char *) "outformat",(char *) "informat", NULL
4368 };
4369
4370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellDateTimeRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
4371 if (obj0) {
4372 {
4373 wxString* sptr = wxString_in_helper(obj0);
4374 if (sptr == NULL) SWIG_fail;
4375 arg1 = *sptr;
4376 delete sptr;
4377 }
4378 }
4379 if (obj1) {
4380 {
4381 wxString* sptr = wxString_in_helper(obj1);
4382 if (sptr == NULL) SWIG_fail;
4383 arg2 = *sptr;
4384 delete sptr;
4385 }
4386 }
4387 {
4388 PyThreadState* __tstate = wxPyBeginAllowThreads();
4389 result = (wxGridCellDateTimeRenderer *)new wxGridCellDateTimeRenderer(arg1,arg2);
4390 wxPyEndAllowThreads(__tstate);
4391 if (PyErr_Occurred()) SWIG_fail;
4392 }
4393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_POINTER_NEW | 0 );
4394 return resultobj;
4395 fail:
4396 return NULL;
4397 }
4398
4399
4400 SWIGINTERN PyObject *GridCellDateTimeRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4401 PyObject *obj;
4402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4403 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellDateTimeRenderer, SWIG_NewClientData(obj));
4404 return SWIG_Py_Void();
4405 }
4406
4407 SWIGINTERN PyObject *GridCellDateTimeRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4408 return SWIG_Python_InitShadowInstance(args);
4409 }
4410
4411 SWIGINTERN PyObject *_wrap_new_GridCellEnumRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4412 PyObject *resultobj = 0;
4413 wxString const &arg1_defvalue = wxPyEmptyString ;
4414 wxString *arg1 = (wxString *) &arg1_defvalue ;
4415 wxGridCellEnumRenderer *result = 0 ;
4416 bool temp1 = false ;
4417 PyObject * obj0 = 0 ;
4418 char * kwnames[] = {
4419 (char *) "choices", NULL
4420 };
4421
4422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumRenderer",kwnames,&obj0)) SWIG_fail;
4423 if (obj0) {
4424 {
4425 arg1 = wxString_in_helper(obj0);
4426 if (arg1 == NULL) SWIG_fail;
4427 temp1 = true;
4428 }
4429 }
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = (wxGridCellEnumRenderer *)new wxGridCellEnumRenderer((wxString const &)*arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_POINTER_NEW | 0 );
4437 {
4438 if (temp1)
4439 delete arg1;
4440 }
4441 return resultobj;
4442 fail:
4443 {
4444 if (temp1)
4445 delete arg1;
4446 }
4447 return NULL;
4448 }
4449
4450
4451 SWIGINTERN PyObject *GridCellEnumRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4452 PyObject *obj;
4453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4454 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumRenderer, SWIG_NewClientData(obj));
4455 return SWIG_Py_Void();
4456 }
4457
4458 SWIGINTERN PyObject *GridCellEnumRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 return SWIG_Python_InitShadowInstance(args);
4460 }
4461
4462 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4463 PyObject *resultobj = 0;
4464 wxGridCellAutoWrapStringRenderer *result = 0 ;
4465
4466 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringRenderer",0,0,0)) SWIG_fail;
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 result = (wxGridCellAutoWrapStringRenderer *)new wxGridCellAutoWrapStringRenderer();
4470 wxPyEndAllowThreads(__tstate);
4471 if (PyErr_Occurred()) SWIG_fail;
4472 }
4473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_POINTER_NEW | 0 );
4474 return resultobj;
4475 fail:
4476 return NULL;
4477 }
4478
4479
4480 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *obj;
4482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4483 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringRenderer, SWIG_NewClientData(obj));
4484 return SWIG_Py_Void();
4485 }
4486
4487 SWIGINTERN PyObject *GridCellAutoWrapStringRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4488 return SWIG_Python_InitShadowInstance(args);
4489 }
4490
4491 SWIGINTERN PyObject *_wrap_GridCellEditor_IsCreated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4494 bool result;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 PyObject *swig_obj[1] ;
4498
4499 if (!args) SWIG_fail;
4500 swig_obj[0] = args;
4501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4502 if (!SWIG_IsOK(res1)) {
4503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsCreated" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4504 }
4505 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4506 {
4507 PyThreadState* __tstate = wxPyBeginAllowThreads();
4508 result = (bool)(arg1)->IsCreated();
4509 wxPyEndAllowThreads(__tstate);
4510 if (PyErr_Occurred()) SWIG_fail;
4511 }
4512 {
4513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4514 }
4515 return resultobj;
4516 fail:
4517 return NULL;
4518 }
4519
4520
4521 SWIGINTERN PyObject *_wrap_GridCellEditor_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4522 PyObject *resultobj = 0;
4523 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4524 wxControl *result = 0 ;
4525 void *argp1 = 0 ;
4526 int res1 = 0 ;
4527 PyObject *swig_obj[1] ;
4528
4529 if (!args) SWIG_fail;
4530 swig_obj[0] = args;
4531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4532 if (!SWIG_IsOK(res1)) {
4533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4534 }
4535 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4536 {
4537 PyThreadState* __tstate = wxPyBeginAllowThreads();
4538 result = (wxControl *)(arg1)->GetControl();
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 {
4543 resultobj = wxPyMake_wxObject(result, 0);
4544 }
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 SWIGINTERN PyObject *_wrap_GridCellEditor_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj = 0;
4553 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4554 wxControl *arg2 = (wxControl *) 0 ;
4555 void *argp1 = 0 ;
4556 int res1 = 0 ;
4557 void *argp2 = 0 ;
4558 int res2 = 0 ;
4559 PyObject * obj0 = 0 ;
4560 PyObject * obj1 = 0 ;
4561 char * kwnames[] = {
4562 (char *) "self",(char *) "control", NULL
4563 };
4564
4565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
4566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4567 if (!SWIG_IsOK(res1)) {
4568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetControl" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4569 }
4570 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
4572 if (!SWIG_IsOK(res2)) {
4573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
4574 }
4575 arg2 = reinterpret_cast< wxControl * >(argp2);
4576 {
4577 PyThreadState* __tstate = wxPyBeginAllowThreads();
4578 (arg1)->SetControl(arg2);
4579 wxPyEndAllowThreads(__tstate);
4580 if (PyErr_Occurred()) SWIG_fail;
4581 }
4582 resultobj = SWIG_Py_Void();
4583 return resultobj;
4584 fail:
4585 return NULL;
4586 }
4587
4588
4589 SWIGINTERN PyObject *_wrap_GridCellEditor_GetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4590 PyObject *resultobj = 0;
4591 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4592 wxGridCellAttr *result = 0 ;
4593 void *argp1 = 0 ;
4594 int res1 = 0 ;
4595 PyObject *swig_obj[1] ;
4596
4597 if (!args) SWIG_fail;
4598 swig_obj[0] = args;
4599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4600 if (!SWIG_IsOK(res1)) {
4601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_GetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4602 }
4603 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4604 {
4605 PyThreadState* __tstate = wxPyBeginAllowThreads();
4606 result = (wxGridCellAttr *)(arg1)->GetCellAttr();
4607 wxPyEndAllowThreads(__tstate);
4608 if (PyErr_Occurred()) SWIG_fail;
4609 }
4610 {
4611 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
4612 }
4613 return resultobj;
4614 fail:
4615 return NULL;
4616 }
4617
4618
4619 SWIGINTERN PyObject *_wrap_GridCellEditor_SetCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4620 PyObject *resultobj = 0;
4621 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4622 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
4623 void *argp1 = 0 ;
4624 int res1 = 0 ;
4625 void *argp2 = 0 ;
4626 int res2 = 0 ;
4627 PyObject * obj0 = 0 ;
4628 PyObject * obj1 = 0 ;
4629 char * kwnames[] = {
4630 (char *) "self",(char *) "attr", NULL
4631 };
4632
4633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetCellAttr",kwnames,&obj0,&obj1)) SWIG_fail;
4634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4635 if (!SWIG_IsOK(res1)) {
4636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4637 }
4638 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4640 if (!SWIG_IsOK(res2)) {
4641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_SetCellAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
4642 }
4643 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 (arg1)->SetCellAttr(arg2);
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_GridCellEditor_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4660 wxWindow *arg2 = (wxWindow *) 0 ;
4661 int arg3 ;
4662 wxEvtHandler *arg4 = (wxEvtHandler *) 0 ;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 void *argp2 = 0 ;
4666 int res2 = 0 ;
4667 int val3 ;
4668 int ecode3 = 0 ;
4669 void *argp4 = 0 ;
4670 int res4 = 0 ;
4671 PyObject * obj0 = 0 ;
4672 PyObject * obj1 = 0 ;
4673 PyObject * obj2 = 0 ;
4674 PyObject * obj3 = 0 ;
4675 char * kwnames[] = {
4676 (char *) "self",(char *) "parent",(char *) "id",(char *) "evtHandler", NULL
4677 };
4678
4679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4681 if (!SWIG_IsOK(res1)) {
4682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Create" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4683 }
4684 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4686 if (!SWIG_IsOK(res2)) {
4687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
4688 }
4689 arg2 = reinterpret_cast< wxWindow * >(argp2);
4690 ecode3 = SWIG_AsVal_int(obj2, &val3);
4691 if (!SWIG_IsOK(ecode3)) {
4692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_Create" "', expected argument " "3"" of type '" "int""'");
4693 }
4694 arg3 = static_cast< int >(val3);
4695 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
4696 if (!SWIG_IsOK(res4)) {
4697 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_Create" "', expected argument " "4"" of type '" "wxEvtHandler *""'");
4698 }
4699 arg4 = reinterpret_cast< wxEvtHandler * >(argp4);
4700 {
4701 PyThreadState* __tstate = wxPyBeginAllowThreads();
4702 (arg1)->Create(arg2,arg3,arg4);
4703 wxPyEndAllowThreads(__tstate);
4704 if (PyErr_Occurred()) SWIG_fail;
4705 }
4706 resultobj = SWIG_Py_Void();
4707 return resultobj;
4708 fail:
4709 return NULL;
4710 }
4711
4712
4713 SWIGINTERN PyObject *_wrap_GridCellEditor_BeginEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4714 PyObject *resultobj = 0;
4715 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4716 int arg2 ;
4717 int arg3 ;
4718 wxGrid *arg4 = (wxGrid *) 0 ;
4719 void *argp1 = 0 ;
4720 int res1 = 0 ;
4721 int val2 ;
4722 int ecode2 = 0 ;
4723 int val3 ;
4724 int ecode3 = 0 ;
4725 void *argp4 = 0 ;
4726 int res4 = 0 ;
4727 PyObject * obj0 = 0 ;
4728 PyObject * obj1 = 0 ;
4729 PyObject * obj2 = 0 ;
4730 PyObject * obj3 = 0 ;
4731 char * kwnames[] = {
4732 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4733 };
4734
4735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_BeginEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4737 if (!SWIG_IsOK(res1)) {
4738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4739 }
4740 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4741 ecode2 = SWIG_AsVal_int(obj1, &val2);
4742 if (!SWIG_IsOK(ecode2)) {
4743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "2"" of type '" "int""'");
4744 }
4745 arg2 = static_cast< int >(val2);
4746 ecode3 = SWIG_AsVal_int(obj2, &val3);
4747 if (!SWIG_IsOK(ecode3)) {
4748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "3"" of type '" "int""'");
4749 }
4750 arg3 = static_cast< int >(val3);
4751 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4752 if (!SWIG_IsOK(res4)) {
4753 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_BeginEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4754 }
4755 arg4 = reinterpret_cast< wxGrid * >(argp4);
4756 {
4757 PyThreadState* __tstate = wxPyBeginAllowThreads();
4758 (arg1)->BeginEdit(arg2,arg3,arg4);
4759 wxPyEndAllowThreads(__tstate);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 resultobj = SWIG_Py_Void();
4763 return resultobj;
4764 fail:
4765 return NULL;
4766 }
4767
4768
4769 SWIGINTERN PyObject *_wrap_GridCellEditor_EndEdit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4770 PyObject *resultobj = 0;
4771 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4772 int arg2 ;
4773 int arg3 ;
4774 wxGrid *arg4 = (wxGrid *) 0 ;
4775 bool result;
4776 void *argp1 = 0 ;
4777 int res1 = 0 ;
4778 int val2 ;
4779 int ecode2 = 0 ;
4780 int val3 ;
4781 int ecode3 = 0 ;
4782 void *argp4 = 0 ;
4783 int res4 = 0 ;
4784 PyObject * obj0 = 0 ;
4785 PyObject * obj1 = 0 ;
4786 PyObject * obj2 = 0 ;
4787 PyObject * obj3 = 0 ;
4788 char * kwnames[] = {
4789 (char *) "self",(char *) "row",(char *) "col",(char *) "grid", NULL
4790 };
4791
4792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellEditor_EndEdit",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4794 if (!SWIG_IsOK(res1)) {
4795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_EndEdit" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4796 }
4797 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4798 ecode2 = SWIG_AsVal_int(obj1, &val2);
4799 if (!SWIG_IsOK(ecode2)) {
4800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_EndEdit" "', expected argument " "2"" of type '" "int""'");
4801 }
4802 arg2 = static_cast< int >(val2);
4803 ecode3 = SWIG_AsVal_int(obj2, &val3);
4804 if (!SWIG_IsOK(ecode3)) {
4805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellEditor_EndEdit" "', expected argument " "3"" of type '" "int""'");
4806 }
4807 arg3 = static_cast< int >(val3);
4808 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGrid, 0 | 0 );
4809 if (!SWIG_IsOK(res4)) {
4810 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridCellEditor_EndEdit" "', expected argument " "4"" of type '" "wxGrid *""'");
4811 }
4812 arg4 = reinterpret_cast< wxGrid * >(argp4);
4813 {
4814 PyThreadState* __tstate = wxPyBeginAllowThreads();
4815 result = (bool)(arg1)->EndEdit(arg2,arg3,arg4);
4816 wxPyEndAllowThreads(__tstate);
4817 if (PyErr_Occurred()) SWIG_fail;
4818 }
4819 {
4820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4821 }
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 SWIGINTERN PyObject *_wrap_GridCellEditor_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4829 PyObject *resultobj = 0;
4830 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4831 void *argp1 = 0 ;
4832 int res1 = 0 ;
4833 PyObject *swig_obj[1] ;
4834
4835 if (!args) SWIG_fail;
4836 swig_obj[0] = args;
4837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4838 if (!SWIG_IsOK(res1)) {
4839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Reset" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4840 }
4841 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4842 {
4843 PyThreadState* __tstate = wxPyBeginAllowThreads();
4844 (arg1)->Reset();
4845 wxPyEndAllowThreads(__tstate);
4846 if (PyErr_Occurred()) SWIG_fail;
4847 }
4848 resultobj = SWIG_Py_Void();
4849 return resultobj;
4850 fail:
4851 return NULL;
4852 }
4853
4854
4855 SWIGINTERN PyObject *_wrap_GridCellEditor_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4856 PyObject *resultobj = 0;
4857 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4858 wxGridCellEditor *result = 0 ;
4859 void *argp1 = 0 ;
4860 int res1 = 0 ;
4861 PyObject *swig_obj[1] ;
4862
4863 if (!args) SWIG_fail;
4864 swig_obj[0] = args;
4865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4866 if (!SWIG_IsOK(res1)) {
4867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Clone" "', expected argument " "1"" of type '" "wxGridCellEditor const *""'");
4868 }
4869 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 result = (wxGridCellEditor *)((wxGridCellEditor const *)arg1)->Clone();
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 {
4877 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
4878 }
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 SWIGINTERN PyObject *_wrap_GridCellEditor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj = 0;
4887 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4888 wxRect *arg2 = 0 ;
4889 void *argp1 = 0 ;
4890 int res1 = 0 ;
4891 wxRect temp2 ;
4892 PyObject * obj0 = 0 ;
4893 PyObject * obj1 = 0 ;
4894 char * kwnames[] = {
4895 (char *) "self",(char *) "rect", NULL
4896 };
4897
4898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
4899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4900 if (!SWIG_IsOK(res1)) {
4901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_SetSize" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4902 }
4903 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4904 {
4905 arg2 = &temp2;
4906 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 (arg1)->SetSize((wxRect const &)*arg2);
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_Py_Void();
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_GridCellEditor_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4922 PyObject *resultobj = 0;
4923 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4924 bool arg2 ;
4925 wxGridCellAttr *arg3 = (wxGridCellAttr *) NULL ;
4926 void *argp1 = 0 ;
4927 int res1 = 0 ;
4928 bool val2 ;
4929 int ecode2 = 0 ;
4930 void *argp3 = 0 ;
4931 int res3 = 0 ;
4932 PyObject * obj0 = 0 ;
4933 PyObject * obj1 = 0 ;
4934 PyObject * obj2 = 0 ;
4935 char * kwnames[] = {
4936 (char *) "self",(char *) "show",(char *) "attr", NULL
4937 };
4938
4939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridCellEditor_Show",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4941 if (!SWIG_IsOK(res1)) {
4942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Show" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4943 }
4944 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4946 if (!SWIG_IsOK(ecode2)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellEditor_Show" "', expected argument " "2"" of type '" "bool""'");
4948 }
4949 arg2 = static_cast< bool >(val2);
4950 if (obj2) {
4951 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4952 if (!SWIG_IsOK(res3)) {
4953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_Show" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
4954 }
4955 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
4956 }
4957 {
4958 PyThreadState* __tstate = wxPyBeginAllowThreads();
4959 (arg1)->Show(arg2,arg3);
4960 wxPyEndAllowThreads(__tstate);
4961 if (PyErr_Occurred()) SWIG_fail;
4962 }
4963 resultobj = SWIG_Py_Void();
4964 return resultobj;
4965 fail:
4966 return NULL;
4967 }
4968
4969
4970 SWIGINTERN PyObject *_wrap_GridCellEditor_PaintBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4971 PyObject *resultobj = 0;
4972 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
4973 wxRect *arg2 = 0 ;
4974 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
4975 void *argp1 = 0 ;
4976 int res1 = 0 ;
4977 wxRect temp2 ;
4978 void *argp3 = 0 ;
4979 int res3 = 0 ;
4980 PyObject * obj0 = 0 ;
4981 PyObject * obj1 = 0 ;
4982 PyObject * obj2 = 0 ;
4983 char * kwnames[] = {
4984 (char *) "self",(char *) "rectCell",(char *) "attr", NULL
4985 };
4986
4987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellEditor_PaintBackground",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
4989 if (!SWIG_IsOK(res1)) {
4990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
4991 }
4992 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
4993 {
4994 arg2 = &temp2;
4995 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4996 }
4997 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
4998 if (!SWIG_IsOK(res3)) {
4999 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridCellEditor_PaintBackground" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
5000 }
5001 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
5002 {
5003 PyThreadState* __tstate = wxPyBeginAllowThreads();
5004 (arg1)->PaintBackground((wxRect const &)*arg2,arg3);
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 resultobj = SWIG_Py_Void();
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_GridCellEditor_IsAcceptedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5016 PyObject *resultobj = 0;
5017 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5018 wxKeyEvent *arg2 = 0 ;
5019 bool result;
5020 void *argp1 = 0 ;
5021 int res1 = 0 ;
5022 void *argp2 = 0 ;
5023 int res2 = 0 ;
5024 PyObject * obj0 = 0 ;
5025 PyObject * obj1 = 0 ;
5026 char * kwnames[] = {
5027 (char *) "self",(char *) "event", NULL
5028 };
5029
5030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_IsAcceptedKey",kwnames,&obj0,&obj1)) SWIG_fail;
5031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5034 }
5035 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5037 if (!SWIG_IsOK(res2)) {
5038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5039 }
5040 if (!argp2) {
5041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_IsAcceptedKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5042 }
5043 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5044 {
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 result = (bool)(arg1)->IsAcceptedKey(*arg2);
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 {
5051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5052 }
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5060 PyObject *resultobj = 0;
5061 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5062 wxKeyEvent *arg2 = 0 ;
5063 void *argp1 = 0 ;
5064 int res1 = 0 ;
5065 void *argp2 = 0 ;
5066 int res2 = 0 ;
5067 PyObject * obj0 = 0 ;
5068 PyObject * obj1 = 0 ;
5069 char * kwnames[] = {
5070 (char *) "self",(char *) "event", NULL
5071 };
5072
5073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_StartingKey",kwnames,&obj0,&obj1)) SWIG_fail;
5074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5075 if (!SWIG_IsOK(res1)) {
5076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingKey" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5077 }
5078 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5080 if (!SWIG_IsOK(res2)) {
5081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5082 }
5083 if (!argp2) {
5084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_StartingKey" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5085 }
5086 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5087 {
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 (arg1)->StartingKey(*arg2);
5090 wxPyEndAllowThreads(__tstate);
5091 if (PyErr_Occurred()) SWIG_fail;
5092 }
5093 resultobj = SWIG_Py_Void();
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 SWIGINTERN PyObject *_wrap_GridCellEditor_StartingClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5101 PyObject *resultobj = 0;
5102 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5103 void *argp1 = 0 ;
5104 int res1 = 0 ;
5105 PyObject *swig_obj[1] ;
5106
5107 if (!args) SWIG_fail;
5108 swig_obj[0] = args;
5109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5110 if (!SWIG_IsOK(res1)) {
5111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_StartingClick" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5112 }
5113 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5114 {
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 (arg1)->StartingClick();
5117 wxPyEndAllowThreads(__tstate);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 resultobj = SWIG_Py_Void();
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 SWIGINTERN PyObject *_wrap_GridCellEditor_HandleReturn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj = 0;
5129 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5130 wxKeyEvent *arg2 = 0 ;
5131 void *argp1 = 0 ;
5132 int res1 = 0 ;
5133 void *argp2 = 0 ;
5134 int res2 = 0 ;
5135 PyObject * obj0 = 0 ;
5136 PyObject * obj1 = 0 ;
5137 char * kwnames[] = {
5138 (char *) "self",(char *) "event", NULL
5139 };
5140
5141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellEditor_HandleReturn",kwnames,&obj0,&obj1)) SWIG_fail;
5142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5143 if (!SWIG_IsOK(res1)) {
5144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5145 }
5146 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 );
5148 if (!SWIG_IsOK(res2)) {
5149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5150 }
5151 if (!argp2) {
5152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellEditor_HandleReturn" "', expected argument " "2"" of type '" "wxKeyEvent &""'");
5153 }
5154 arg2 = reinterpret_cast< wxKeyEvent * >(argp2);
5155 {
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 (arg1)->HandleReturn(*arg2);
5158 wxPyEndAllowThreads(__tstate);
5159 if (PyErr_Occurred()) SWIG_fail;
5160 }
5161 resultobj = SWIG_Py_Void();
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
5168 SWIGINTERN PyObject *_wrap_GridCellEditor_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5169 PyObject *resultobj = 0;
5170 wxGridCellEditor *arg1 = (wxGridCellEditor *) 0 ;
5171 void *argp1 = 0 ;
5172 int res1 = 0 ;
5173 PyObject *swig_obj[1] ;
5174
5175 if (!args) SWIG_fail;
5176 swig_obj[0] = args;
5177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
5178 if (!SWIG_IsOK(res1)) {
5179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellEditor_Destroy" "', expected argument " "1"" of type '" "wxGridCellEditor *""'");
5180 }
5181 arg1 = reinterpret_cast< wxGridCellEditor * >(argp1);
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 (arg1)->Destroy();
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 resultobj = SWIG_Py_Void();
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 SWIGINTERN PyObject *GridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5196 PyObject *obj;
5197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5198 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEditor, SWIG_NewClientData(obj));
5199 return SWIG_Py_Void();
5200 }
5201
5202 SWIGINTERN PyObject *_wrap_new_PyGridCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5203 PyObject *resultobj = 0;
5204 wxPyGridCellEditor *result = 0 ;
5205
5206 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellEditor",0,0,0)) SWIG_fail;
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (wxPyGridCellEditor *)new wxPyGridCellEditor();
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellEditor, SWIG_POINTER_NEW | 0 );
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_PyGridCellEditor__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5223 PyObject *arg2 = (PyObject *) 0 ;
5224 PyObject *arg3 = (PyObject *) 0 ;
5225 void *argp1 = 0 ;
5226 int res1 = 0 ;
5227 PyObject * obj0 = 0 ;
5228 PyObject * obj1 = 0 ;
5229 PyObject * obj2 = 0 ;
5230 char * kwnames[] = {
5231 (char *) "self",(char *) "self",(char *) "_class", NULL
5232 };
5233
5234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellEditor__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5238 }
5239 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5240 arg2 = obj1;
5241 arg3 = obj2;
5242 {
5243 PyThreadState* __tstate = wxPyBeginAllowThreads();
5244 (arg1)->_setCallbackInfo(arg2,arg3);
5245 wxPyEndAllowThreads(__tstate);
5246 if (PyErr_Occurred()) SWIG_fail;
5247 }
5248 resultobj = SWIG_Py_Void();
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 SWIGINTERN PyObject *_wrap_PyGridCellEditor_SetParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5256 PyObject *resultobj = 0;
5257 wxPyGridCellEditor *arg1 = (wxPyGridCellEditor *) 0 ;
5258 wxString *arg2 = 0 ;
5259 void *argp1 = 0 ;
5260 int res1 = 0 ;
5261 bool temp2 = false ;
5262 PyObject * obj0 = 0 ;
5263 PyObject * obj1 = 0 ;
5264 char * kwnames[] = {
5265 (char *) "self",(char *) "params", NULL
5266 };
5267
5268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyGridCellEditor_SetParameters",kwnames,&obj0,&obj1)) SWIG_fail;
5269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellEditor, 0 | 0 );
5270 if (!SWIG_IsOK(res1)) {
5271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellEditor_SetParameters" "', expected argument " "1"" of type '" "wxPyGridCellEditor *""'");
5272 }
5273 arg1 = reinterpret_cast< wxPyGridCellEditor * >(argp1);
5274 {
5275 arg2 = wxString_in_helper(obj1);
5276 if (arg2 == NULL) SWIG_fail;
5277 temp2 = true;
5278 }
5279 {
5280 PyThreadState* __tstate = wxPyBeginAllowThreads();
5281 (arg1)->SetParameters((wxString const &)*arg2);
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 resultobj = SWIG_Py_Void();
5286 {
5287 if (temp2)
5288 delete arg2;
5289 }
5290 return resultobj;
5291 fail:
5292 {
5293 if (temp2)
5294 delete arg2;
5295 }
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *PyGridCellEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5301 PyObject *obj;
5302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5303 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellEditor, SWIG_NewClientData(obj));
5304 return SWIG_Py_Void();
5305 }
5306
5307 SWIGINTERN PyObject *PyGridCellEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5308 return SWIG_Python_InitShadowInstance(args);
5309 }
5310
5311 SWIGINTERN PyObject *_wrap_new_GridCellTextEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 wxGridCellTextEditor *result = 0 ;
5314
5315 if (!SWIG_Python_UnpackTuple(args,"new_GridCellTextEditor",0,0,0)) SWIG_fail;
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 result = (wxGridCellTextEditor *)new wxGridCellTextEditor();
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellTextEditor, SWIG_POINTER_NEW | 0 );
5323 return resultobj;
5324 fail:
5325 return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_GridCellTextEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330 PyObject *resultobj = 0;
5331 wxGridCellTextEditor *arg1 = (wxGridCellTextEditor *) 0 ;
5332 wxString result;
5333 void *argp1 = 0 ;
5334 int res1 = 0 ;
5335 PyObject *swig_obj[1] ;
5336
5337 if (!args) SWIG_fail;
5338 swig_obj[0] = args;
5339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellTextEditor, 0 | 0 );
5340 if (!SWIG_IsOK(res1)) {
5341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellTextEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellTextEditor *""'");
5342 }
5343 arg1 = reinterpret_cast< wxGridCellTextEditor * >(argp1);
5344 {
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 result = (arg1)->GetValue();
5347 wxPyEndAllowThreads(__tstate);
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 {
5351 #if wxUSE_UNICODE
5352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5353 #else
5354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5355 #endif
5356 }
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *GridCellTextEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5364 PyObject *obj;
5365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5366 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellTextEditor, SWIG_NewClientData(obj));
5367 return SWIG_Py_Void();
5368 }
5369
5370 SWIGINTERN PyObject *GridCellTextEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5371 return SWIG_Python_InitShadowInstance(args);
5372 }
5373
5374 SWIGINTERN PyObject *_wrap_new_GridCellNumberEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj = 0;
5376 int arg1 = (int) -1 ;
5377 int arg2 = (int) -1 ;
5378 wxGridCellNumberEditor *result = 0 ;
5379 int val1 ;
5380 int ecode1 = 0 ;
5381 int val2 ;
5382 int ecode2 = 0 ;
5383 PyObject * obj0 = 0 ;
5384 PyObject * obj1 = 0 ;
5385 char * kwnames[] = {
5386 (char *) "min",(char *) "max", NULL
5387 };
5388
5389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellNumberEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5390 if (obj0) {
5391 ecode1 = SWIG_AsVal_int(obj0, &val1);
5392 if (!SWIG_IsOK(ecode1)) {
5393 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellNumberEditor" "', expected argument " "1"" of type '" "int""'");
5394 }
5395 arg1 = static_cast< int >(val1);
5396 }
5397 if (obj1) {
5398 ecode2 = SWIG_AsVal_int(obj1, &val2);
5399 if (!SWIG_IsOK(ecode2)) {
5400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellNumberEditor" "', expected argument " "2"" of type '" "int""'");
5401 }
5402 arg2 = static_cast< int >(val2);
5403 }
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 result = (wxGridCellNumberEditor *)new wxGridCellNumberEditor(arg1,arg2);
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellNumberEditor, SWIG_POINTER_NEW | 0 );
5411 return resultobj;
5412 fail:
5413 return NULL;
5414 }
5415
5416
5417 SWIGINTERN PyObject *GridCellNumberEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 PyObject *obj;
5419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5420 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellNumberEditor, SWIG_NewClientData(obj));
5421 return SWIG_Py_Void();
5422 }
5423
5424 SWIGINTERN PyObject *GridCellNumberEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425 return SWIG_Python_InitShadowInstance(args);
5426 }
5427
5428 SWIGINTERN PyObject *_wrap_new_GridCellFloatEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj = 0;
5430 int arg1 = (int) -1 ;
5431 int arg2 = (int) -1 ;
5432 wxGridCellFloatEditor *result = 0 ;
5433 int val1 ;
5434 int ecode1 = 0 ;
5435 int val2 ;
5436 int ecode2 = 0 ;
5437 PyObject * obj0 = 0 ;
5438 PyObject * obj1 = 0 ;
5439 char * kwnames[] = {
5440 (char *) "width",(char *) "precision", NULL
5441 };
5442
5443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellFloatEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5444 if (obj0) {
5445 ecode1 = SWIG_AsVal_int(obj0, &val1);
5446 if (!SWIG_IsOK(ecode1)) {
5447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellFloatEditor" "', expected argument " "1"" of type '" "int""'");
5448 }
5449 arg1 = static_cast< int >(val1);
5450 }
5451 if (obj1) {
5452 ecode2 = SWIG_AsVal_int(obj1, &val2);
5453 if (!SWIG_IsOK(ecode2)) {
5454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellFloatEditor" "', expected argument " "2"" of type '" "int""'");
5455 }
5456 arg2 = static_cast< int >(val2);
5457 }
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 result = (wxGridCellFloatEditor *)new wxGridCellFloatEditor(arg1,arg2);
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellFloatEditor, SWIG_POINTER_NEW | 0 );
5465 return resultobj;
5466 fail:
5467 return NULL;
5468 }
5469
5470
5471 SWIGINTERN PyObject *GridCellFloatEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5472 PyObject *obj;
5473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5474 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellFloatEditor, SWIG_NewClientData(obj));
5475 return SWIG_Py_Void();
5476 }
5477
5478 SWIGINTERN PyObject *GridCellFloatEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5479 return SWIG_Python_InitShadowInstance(args);
5480 }
5481
5482 SWIGINTERN PyObject *_wrap_new_GridCellBoolEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5483 PyObject *resultobj = 0;
5484 wxGridCellBoolEditor *result = 0 ;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"new_GridCellBoolEditor",0,0,0)) SWIG_fail;
5487 {
5488 PyThreadState* __tstate = wxPyBeginAllowThreads();
5489 result = (wxGridCellBoolEditor *)new wxGridCellBoolEditor();
5490 wxPyEndAllowThreads(__tstate);
5491 if (PyErr_Occurred()) SWIG_fail;
5492 }
5493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellBoolEditor, SWIG_POINTER_NEW | 0 );
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 SWIGINTERN PyObject *_wrap_GridCellBoolEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5501 PyObject *resultobj = 0;
5502 wxGridCellBoolEditor *arg1 = (wxGridCellBoolEditor *) 0 ;
5503 wxString result;
5504 void *argp1 = 0 ;
5505 int res1 = 0 ;
5506 PyObject *swig_obj[1] ;
5507
5508 if (!args) SWIG_fail;
5509 swig_obj[0] = args;
5510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellBoolEditor, 0 | 0 );
5511 if (!SWIG_IsOK(res1)) {
5512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellBoolEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellBoolEditor *""'");
5513 }
5514 arg1 = reinterpret_cast< wxGridCellBoolEditor * >(argp1);
5515 {
5516 PyThreadState* __tstate = wxPyBeginAllowThreads();
5517 result = (arg1)->GetValue();
5518 wxPyEndAllowThreads(__tstate);
5519 if (PyErr_Occurred()) SWIG_fail;
5520 }
5521 {
5522 #if wxUSE_UNICODE
5523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5524 #else
5525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5526 #endif
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 SWIGINTERN PyObject *GridCellBoolEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5535 PyObject *obj;
5536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5537 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellBoolEditor, SWIG_NewClientData(obj));
5538 return SWIG_Py_Void();
5539 }
5540
5541 SWIGINTERN PyObject *GridCellBoolEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5542 return SWIG_Python_InitShadowInstance(args);
5543 }
5544
5545 SWIGINTERN PyObject *_wrap_new_GridCellChoiceEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5546 PyObject *resultobj = 0;
5547 int arg1 = (int) 0 ;
5548 wxString *arg2 = (wxString *) NULL ;
5549 bool arg3 = (bool) false ;
5550 wxGridCellChoiceEditor *result = 0 ;
5551 bool val3 ;
5552 int ecode3 = 0 ;
5553 PyObject * obj0 = 0 ;
5554 PyObject * obj1 = 0 ;
5555 char * kwnames[] = {
5556 (char *) "choices",(char *) "allowOthers", NULL
5557 };
5558
5559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellChoiceEditor",kwnames,&obj0,&obj1)) SWIG_fail;
5560 if (obj0) {
5561 {
5562 arg1 = PyList_Size(obj0);
5563 arg2 = wxString_LIST_helper(obj0);
5564 if (arg2 == NULL) SWIG_fail;
5565 }
5566 }
5567 if (obj1) {
5568 ecode3 = SWIG_AsVal_bool(obj1, &val3);
5569 if (!SWIG_IsOK(ecode3)) {
5570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridCellChoiceEditor" "', expected argument " "3"" of type '" "bool""'");
5571 }
5572 arg3 = static_cast< bool >(val3);
5573 }
5574 {
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 result = (wxGridCellChoiceEditor *)new wxGridCellChoiceEditor(arg1,(wxString const *)arg2,arg3);
5577 wxPyEndAllowThreads(__tstate);
5578 if (PyErr_Occurred()) SWIG_fail;
5579 }
5580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_POINTER_NEW | 0 );
5581 {
5582 if (arg2) delete [] arg2;
5583 }
5584 return resultobj;
5585 fail:
5586 {
5587 if (arg2) delete [] arg2;
5588 }
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *_wrap_GridCellChoiceEditor_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *resultobj = 0;
5595 wxGridCellChoiceEditor *arg1 = (wxGridCellChoiceEditor *) 0 ;
5596 wxString result;
5597 void *argp1 = 0 ;
5598 int res1 = 0 ;
5599 PyObject *swig_obj[1] ;
5600
5601 if (!args) SWIG_fail;
5602 swig_obj[0] = args;
5603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellChoiceEditor, 0 | 0 );
5604 if (!SWIG_IsOK(res1)) {
5605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellChoiceEditor_GetValue" "', expected argument " "1"" of type '" "wxGridCellChoiceEditor *""'");
5606 }
5607 arg1 = reinterpret_cast< wxGridCellChoiceEditor * >(argp1);
5608 {
5609 PyThreadState* __tstate = wxPyBeginAllowThreads();
5610 result = (arg1)->GetValue();
5611 wxPyEndAllowThreads(__tstate);
5612 if (PyErr_Occurred()) SWIG_fail;
5613 }
5614 {
5615 #if wxUSE_UNICODE
5616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5617 #else
5618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5619 #endif
5620 }
5621 return resultobj;
5622 fail:
5623 return NULL;
5624 }
5625
5626
5627 SWIGINTERN PyObject *GridCellChoiceEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5628 PyObject *obj;
5629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5630 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellChoiceEditor, SWIG_NewClientData(obj));
5631 return SWIG_Py_Void();
5632 }
5633
5634 SWIGINTERN PyObject *GridCellChoiceEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 return SWIG_Python_InitShadowInstance(args);
5636 }
5637
5638 SWIGINTERN PyObject *_wrap_new_GridCellEnumEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj = 0;
5640 wxString const &arg1_defvalue = wxPyEmptyString ;
5641 wxString *arg1 = (wxString *) &arg1_defvalue ;
5642 wxGridCellEnumEditor *result = 0 ;
5643 bool temp1 = false ;
5644 PyObject * obj0 = 0 ;
5645 char * kwnames[] = {
5646 (char *) "choices", NULL
5647 };
5648
5649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellEnumEditor",kwnames,&obj0)) SWIG_fail;
5650 if (obj0) {
5651 {
5652 arg1 = wxString_in_helper(obj0);
5653 if (arg1 == NULL) SWIG_fail;
5654 temp1 = true;
5655 }
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 result = (wxGridCellEnumEditor *)new wxGridCellEnumEditor((wxString const &)*arg1);
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellEnumEditor, SWIG_POINTER_NEW | 0 );
5664 {
5665 if (temp1)
5666 delete arg1;
5667 }
5668 return resultobj;
5669 fail:
5670 {
5671 if (temp1)
5672 delete arg1;
5673 }
5674 return NULL;
5675 }
5676
5677
5678 SWIGINTERN PyObject *GridCellEnumEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5679 PyObject *obj;
5680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5681 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellEnumEditor, SWIG_NewClientData(obj));
5682 return SWIG_Py_Void();
5683 }
5684
5685 SWIGINTERN PyObject *GridCellEnumEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5686 return SWIG_Python_InitShadowInstance(args);
5687 }
5688
5689 SWIGINTERN PyObject *_wrap_new_GridCellAutoWrapStringEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5690 PyObject *resultobj = 0;
5691 wxGridCellAutoWrapStringEditor *result = 0 ;
5692
5693 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAutoWrapStringEditor",0,0,0)) SWIG_fail;
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 result = (wxGridCellAutoWrapStringEditor *)new wxGridCellAutoWrapStringEditor();
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_POINTER_NEW | 0 );
5701 return resultobj;
5702 fail:
5703 return NULL;
5704 }
5705
5706
5707 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5708 PyObject *obj;
5709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5710 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAutoWrapStringEditor, SWIG_NewClientData(obj));
5711 return SWIG_Py_Void();
5712 }
5713
5714 SWIGINTERN PyObject *GridCellAutoWrapStringEditor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5715 return SWIG_Python_InitShadowInstance(args);
5716 }
5717
5718 SWIGINTERN PyObject *_wrap_GridCellAttr__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5719 PyObject *resultobj = 0;
5720 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5721 PyObject *arg2 = (PyObject *) 0 ;
5722 void *argp1 = 0 ;
5723 int res1 = 0 ;
5724 PyObject * obj0 = 0 ;
5725 PyObject * obj1 = 0 ;
5726 char * kwnames[] = {
5727 (char *) "self",(char *) "_self", NULL
5728 };
5729
5730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
5731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5732 if (!SWIG_IsOK(res1)) {
5733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5734 }
5735 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5736 arg2 = obj1;
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 wxGridCellAttr__setOORInfo(arg1,arg2);
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 resultobj = SWIG_Py_Void();
5744 return resultobj;
5745 fail:
5746 return NULL;
5747 }
5748
5749
5750 SWIGINTERN PyObject *_wrap_new_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5751 PyObject *resultobj = 0;
5752 wxGridCellAttr *arg1 = (wxGridCellAttr *) NULL ;
5753 wxGridCellAttr *result = 0 ;
5754 void *argp1 = 0 ;
5755 int res1 = 0 ;
5756 PyObject * obj0 = 0 ;
5757 char * kwnames[] = {
5758 (char *) "attrDefault", NULL
5759 };
5760
5761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_GridCellAttr",kwnames,&obj0)) SWIG_fail;
5762 if (obj0) {
5763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5764 if (!SWIG_IsOK(res1)) {
5765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5766 }
5767 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5768 }
5769 {
5770 PyThreadState* __tstate = wxPyBeginAllowThreads();
5771 result = (wxGridCellAttr *)new wxGridCellAttr(arg1);
5772 wxPyEndAllowThreads(__tstate);
5773 if (PyErr_Occurred()) SWIG_fail;
5774 }
5775 {
5776 resultobj = wxPyMake_wxGridCellAttr(result, (bool)SWIG_POINTER_NEW);
5777 }
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 SWIGINTERN PyObject *_wrap_delete_GridCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5785 PyObject *resultobj = 0;
5786 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5787 void *argp1 = 0 ;
5788 int res1 = 0 ;
5789 PyObject *swig_obj[1] ;
5790
5791 if (!args) SWIG_fail;
5792 swig_obj[0] = args;
5793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, SWIG_POINTER_DISOWN | 0 );
5794 if (!SWIG_IsOK(res1)) {
5795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5796 }
5797 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5798 {
5799 PyThreadState* __tstate = wxPyBeginAllowThreads();
5800 delete_wxGridCellAttr(arg1);
5801
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 resultobj = SWIG_Py_Void();
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 SWIGINTERN PyObject *_wrap_GridCellAttr_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5813 PyObject *resultobj = 0;
5814 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5815 wxGridCellAttr *result = 0 ;
5816 void *argp1 = 0 ;
5817 int res1 = 0 ;
5818 PyObject *swig_obj[1] ;
5819
5820 if (!args) SWIG_fail;
5821 swig_obj[0] = args;
5822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5823 if (!SWIG_IsOK(res1)) {
5824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_Clone" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
5825 }
5826 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 result = (wxGridCellAttr *)((wxGridCellAttr const *)arg1)->Clone();
5830 wxPyEndAllowThreads(__tstate);
5831 if (PyErr_Occurred()) SWIG_fail;
5832 }
5833 {
5834 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
5835 }
5836 return resultobj;
5837 fail:
5838 return NULL;
5839 }
5840
5841
5842 SWIGINTERN PyObject *_wrap_GridCellAttr_MergeWith(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj = 0;
5844 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5845 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
5846 void *argp1 = 0 ;
5847 int res1 = 0 ;
5848 void *argp2 = 0 ;
5849 int res2 = 0 ;
5850 PyObject * obj0 = 0 ;
5851 PyObject * obj1 = 0 ;
5852 char * kwnames[] = {
5853 (char *) "self",(char *) "mergefrom", NULL
5854 };
5855
5856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_MergeWith",kwnames,&obj0,&obj1)) SWIG_fail;
5857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5858 if (!SWIG_IsOK(res1)) {
5859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_MergeWith" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5860 }
5861 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5863 if (!SWIG_IsOK(res2)) {
5864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_MergeWith" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
5865 }
5866 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
5867 {
5868 PyThreadState* __tstate = wxPyBeginAllowThreads();
5869 (arg1)->MergeWith(arg2);
5870 wxPyEndAllowThreads(__tstate);
5871 if (PyErr_Occurred()) SWIG_fail;
5872 }
5873 resultobj = SWIG_Py_Void();
5874 return resultobj;
5875 fail:
5876 return NULL;
5877 }
5878
5879
5880 SWIGINTERN PyObject *_wrap_GridCellAttr_IncRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5881 PyObject *resultobj = 0;
5882 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5883 void *argp1 = 0 ;
5884 int res1 = 0 ;
5885 PyObject *swig_obj[1] ;
5886
5887 if (!args) SWIG_fail;
5888 swig_obj[0] = args;
5889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5890 if (!SWIG_IsOK(res1)) {
5891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IncRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5892 }
5893 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5894 {
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 (arg1)->IncRef();
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 resultobj = SWIG_Py_Void();
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *_wrap_GridCellAttr_DecRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5908 PyObject *resultobj = 0;
5909 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 PyObject *swig_obj[1] ;
5913
5914 if (!args) SWIG_fail;
5915 swig_obj[0] = args;
5916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5917 if (!SWIG_IsOK(res1)) {
5918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_DecRef" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5919 }
5920 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5921 {
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 (arg1)->DecRef();
5924 wxPyEndAllowThreads(__tstate);
5925 if (PyErr_Occurred()) SWIG_fail;
5926 }
5927 resultobj = SWIG_Py_Void();
5928 return resultobj;
5929 fail:
5930 return NULL;
5931 }
5932
5933
5934 SWIGINTERN PyObject *_wrap_GridCellAttr_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj = 0;
5936 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5937 wxColour *arg2 = 0 ;
5938 void *argp1 = 0 ;
5939 int res1 = 0 ;
5940 wxColour temp2 ;
5941 PyObject * obj0 = 0 ;
5942 PyObject * obj1 = 0 ;
5943 char * kwnames[] = {
5944 (char *) "self",(char *) "colText", NULL
5945 };
5946
5947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
5948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5949 if (!SWIG_IsOK(res1)) {
5950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5951 }
5952 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5953 {
5954 arg2 = &temp2;
5955 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5956 }
5957 {
5958 PyThreadState* __tstate = wxPyBeginAllowThreads();
5959 (arg1)->SetTextColour((wxColour const &)*arg2);
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 resultobj = SWIG_Py_Void();
5964 return resultobj;
5965 fail:
5966 return NULL;
5967 }
5968
5969
5970 SWIGINTERN PyObject *_wrap_GridCellAttr_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5971 PyObject *resultobj = 0;
5972 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
5973 wxColour *arg2 = 0 ;
5974 void *argp1 = 0 ;
5975 int res1 = 0 ;
5976 wxColour temp2 ;
5977 PyObject * obj0 = 0 ;
5978 PyObject * obj1 = 0 ;
5979 char * kwnames[] = {
5980 (char *) "self",(char *) "colBack", NULL
5981 };
5982
5983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
5984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
5985 if (!SWIG_IsOK(res1)) {
5986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
5987 }
5988 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
5989 {
5990 arg2 = &temp2;
5991 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5992 }
5993 {
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
5996 wxPyEndAllowThreads(__tstate);
5997 if (PyErr_Occurred()) SWIG_fail;
5998 }
5999 resultobj = SWIG_Py_Void();
6000 return resultobj;
6001 fail:
6002 return NULL;
6003 }
6004
6005
6006 SWIGINTERN PyObject *_wrap_GridCellAttr_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj = 0;
6008 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6009 wxFont *arg2 = 0 ;
6010 void *argp1 = 0 ;
6011 int res1 = 0 ;
6012 void *argp2 = 0 ;
6013 int res2 = 0 ;
6014 PyObject * obj0 = 0 ;
6015 PyObject * obj1 = 0 ;
6016 char * kwnames[] = {
6017 (char *) "self",(char *) "font", NULL
6018 };
6019
6020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
6021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6022 if (!SWIG_IsOK(res1)) {
6023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetFont" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6024 }
6025 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6026 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
6027 if (!SWIG_IsOK(res2)) {
6028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6029 }
6030 if (!argp2) {
6031 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridCellAttr_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
6032 }
6033 arg2 = reinterpret_cast< wxFont * >(argp2);
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 (arg1)->SetFont((wxFont const &)*arg2);
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 resultobj = SWIG_Py_Void();
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 SWIGINTERN PyObject *_wrap_GridCellAttr_SetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj = 0;
6049 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6050 int arg2 ;
6051 int arg3 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 int val2 ;
6055 int ecode2 = 0 ;
6056 int val3 ;
6057 int ecode3 = 0 ;
6058 PyObject * obj0 = 0 ;
6059 PyObject * obj1 = 0 ;
6060 PyObject * obj2 = 0 ;
6061 char * kwnames[] = {
6062 (char *) "self",(char *) "hAlign",(char *) "vAlign", NULL
6063 };
6064
6065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6067 if (!SWIG_IsOK(res1)) {
6068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6069 }
6070 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6071 ecode2 = SWIG_AsVal_int(obj1, &val2);
6072 if (!SWIG_IsOK(ecode2)) {
6073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "2"" of type '" "int""'");
6074 }
6075 arg2 = static_cast< int >(val2);
6076 ecode3 = SWIG_AsVal_int(obj2, &val3);
6077 if (!SWIG_IsOK(ecode3)) {
6078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetAlignment" "', expected argument " "3"" of type '" "int""'");
6079 }
6080 arg3 = static_cast< int >(val3);
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 (arg1)->SetAlignment(arg2,arg3);
6084 wxPyEndAllowThreads(__tstate);
6085 if (PyErr_Occurred()) SWIG_fail;
6086 }
6087 resultobj = SWIG_Py_Void();
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 SWIGINTERN PyObject *_wrap_GridCellAttr_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj = 0;
6096 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6097 int arg2 ;
6098 int arg3 ;
6099 void *argp1 = 0 ;
6100 int res1 = 0 ;
6101 int val2 ;
6102 int ecode2 = 0 ;
6103 int val3 ;
6104 int ecode3 = 0 ;
6105 PyObject * obj0 = 0 ;
6106 PyObject * obj1 = 0 ;
6107 PyObject * obj2 = 0 ;
6108 char * kwnames[] = {
6109 (char *) "self",(char *) "num_rows",(char *) "num_cols", NULL
6110 };
6111
6112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttr_SetSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6114 if (!SWIG_IsOK(res1)) {
6115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetSize" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6116 }
6117 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6118 ecode2 = SWIG_AsVal_int(obj1, &val2);
6119 if (!SWIG_IsOK(ecode2)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetSize" "', expected argument " "2"" of type '" "int""'");
6121 }
6122 arg2 = static_cast< int >(val2);
6123 ecode3 = SWIG_AsVal_int(obj2, &val3);
6124 if (!SWIG_IsOK(ecode3)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_SetSize" "', expected argument " "3"" of type '" "int""'");
6126 }
6127 arg3 = static_cast< int >(val3);
6128 {
6129 PyThreadState* __tstate = wxPyBeginAllowThreads();
6130 (arg1)->SetSize(arg2,arg3);
6131 wxPyEndAllowThreads(__tstate);
6132 if (PyErr_Occurred()) SWIG_fail;
6133 }
6134 resultobj = SWIG_Py_Void();
6135 return resultobj;
6136 fail:
6137 return NULL;
6138 }
6139
6140
6141 SWIGINTERN PyObject *_wrap_GridCellAttr_SetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6142 PyObject *resultobj = 0;
6143 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6144 bool arg2 = (bool) true ;
6145 void *argp1 = 0 ;
6146 int res1 = 0 ;
6147 bool val2 ;
6148 int ecode2 = 0 ;
6149 PyObject * obj0 = 0 ;
6150 PyObject * obj1 = 0 ;
6151 char * kwnames[] = {
6152 (char *) "self",(char *) "allow", NULL
6153 };
6154
6155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
6156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6157 if (!SWIG_IsOK(res1)) {
6158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6159 }
6160 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6161 if (obj1) {
6162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6163 if (!SWIG_IsOK(ecode2)) {
6164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetOverflow" "', expected argument " "2"" of type '" "bool""'");
6165 }
6166 arg2 = static_cast< bool >(val2);
6167 }
6168 {
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 (arg1)->SetOverflow(arg2);
6171 wxPyEndAllowThreads(__tstate);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 resultobj = SWIG_Py_Void();
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 SWIGINTERN PyObject *_wrap_GridCellAttr_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj = 0;
6183 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6184 bool arg2 = (bool) true ;
6185 void *argp1 = 0 ;
6186 int res1 = 0 ;
6187 bool val2 ;
6188 int ecode2 = 0 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 char * kwnames[] = {
6192 (char *) "self",(char *) "isReadOnly", NULL
6193 };
6194
6195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridCellAttr_SetReadOnly",kwnames,&obj0,&obj1)) SWIG_fail;
6196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6197 if (!SWIG_IsOK(res1)) {
6198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6199 }
6200 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6201 if (obj1) {
6202 ecode2 = SWIG_AsVal_bool(obj1, &val2);
6203 if (!SWIG_IsOK(ecode2)) {
6204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetReadOnly" "', expected argument " "2"" of type '" "bool""'");
6205 }
6206 arg2 = static_cast< bool >(val2);
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 (arg1)->SetReadOnly(arg2);
6211 wxPyEndAllowThreads(__tstate);
6212 if (PyErr_Occurred()) SWIG_fail;
6213 }
6214 resultobj = SWIG_Py_Void();
6215 return resultobj;
6216 fail:
6217 return NULL;
6218 }
6219
6220
6221 SWIGINTERN PyObject *_wrap_GridCellAttr_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj = 0;
6223 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6224 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
6225 void *argp1 = 0 ;
6226 int res1 = 0 ;
6227 void *argp2 = 0 ;
6228 int res2 = 0 ;
6229 PyObject * obj0 = 0 ;
6230 PyObject * obj1 = 0 ;
6231 char * kwnames[] = {
6232 (char *) "self",(char *) "renderer", NULL
6233 };
6234
6235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
6236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6237 if (!SWIG_IsOK(res1)) {
6238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6239 }
6240 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
6242 if (!SWIG_IsOK(res2)) {
6243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
6244 }
6245 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
6246 {
6247 PyThreadState* __tstate = wxPyBeginAllowThreads();
6248 (arg1)->SetRenderer(arg2);
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 resultobj = SWIG_Py_Void();
6253 return resultobj;
6254 fail:
6255 return NULL;
6256 }
6257
6258
6259 SWIGINTERN PyObject *_wrap_GridCellAttr_SetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6260 PyObject *resultobj = 0;
6261 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6262 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
6263 void *argp1 = 0 ;
6264 int res1 = 0 ;
6265 void *argp2 = 0 ;
6266 int res2 = 0 ;
6267 PyObject * obj0 = 0 ;
6268 PyObject * obj1 = 0 ;
6269 char * kwnames[] = {
6270 (char *) "self",(char *) "editor", NULL
6271 };
6272
6273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetEditor",kwnames,&obj0,&obj1)) SWIG_fail;
6274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6275 if (!SWIG_IsOK(res1)) {
6276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6277 }
6278 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
6280 if (!SWIG_IsOK(res2)) {
6281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
6282 }
6283 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
6284 {
6285 PyThreadState* __tstate = wxPyBeginAllowThreads();
6286 (arg1)->SetEditor(arg2);
6287 wxPyEndAllowThreads(__tstate);
6288 if (PyErr_Occurred()) SWIG_fail;
6289 }
6290 resultobj = SWIG_Py_Void();
6291 return resultobj;
6292 fail:
6293 return NULL;
6294 }
6295
6296
6297 SWIGINTERN PyObject *_wrap_GridCellAttr_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6298 PyObject *resultobj = 0;
6299 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6300 wxGridCellAttr::wxAttrKind arg2 ;
6301 void *argp1 = 0 ;
6302 int res1 = 0 ;
6303 int val2 ;
6304 int ecode2 = 0 ;
6305 PyObject * obj0 = 0 ;
6306 PyObject * obj1 = 0 ;
6307 char * kwnames[] = {
6308 (char *) "self",(char *) "kind", NULL
6309 };
6310
6311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
6312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6313 if (!SWIG_IsOK(res1)) {
6314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6315 }
6316 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6317 ecode2 = SWIG_AsVal_int(obj1, &val2);
6318 if (!SWIG_IsOK(ecode2)) {
6319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttr_SetKind" "', expected argument " "2"" of type '" "wxGridCellAttr::wxAttrKind""'");
6320 }
6321 arg2 = static_cast< wxGridCellAttr::wxAttrKind >(val2);
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 (arg1)->SetKind(arg2);
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 resultobj = SWIG_Py_Void();
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 SWIGINTERN PyObject *_wrap_GridCellAttr_HasTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6336 PyObject *resultobj = 0;
6337 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6338 bool result;
6339 void *argp1 = 0 ;
6340 int res1 = 0 ;
6341 PyObject *swig_obj[1] ;
6342
6343 if (!args) SWIG_fail;
6344 swig_obj[0] = args;
6345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6346 if (!SWIG_IsOK(res1)) {
6347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6348 }
6349 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6350 {
6351 PyThreadState* __tstate = wxPyBeginAllowThreads();
6352 result = (bool)((wxGridCellAttr const *)arg1)->HasTextColour();
6353 wxPyEndAllowThreads(__tstate);
6354 if (PyErr_Occurred()) SWIG_fail;
6355 }
6356 {
6357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6358 }
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 SWIGINTERN PyObject *_wrap_GridCellAttr_HasBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6366 PyObject *resultobj = 0;
6367 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6368 bool result;
6369 void *argp1 = 0 ;
6370 int res1 = 0 ;
6371 PyObject *swig_obj[1] ;
6372
6373 if (!args) SWIG_fail;
6374 swig_obj[0] = args;
6375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6376 if (!SWIG_IsOK(res1)) {
6377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6378 }
6379 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6380 {
6381 PyThreadState* __tstate = wxPyBeginAllowThreads();
6382 result = (bool)((wxGridCellAttr const *)arg1)->HasBackgroundColour();
6383 wxPyEndAllowThreads(__tstate);
6384 if (PyErr_Occurred()) SWIG_fail;
6385 }
6386 {
6387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6388 }
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 SWIGINTERN PyObject *_wrap_GridCellAttr_HasFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6396 PyObject *resultobj = 0;
6397 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6398 bool result;
6399 void *argp1 = 0 ;
6400 int res1 = 0 ;
6401 PyObject *swig_obj[1] ;
6402
6403 if (!args) SWIG_fail;
6404 swig_obj[0] = args;
6405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6406 if (!SWIG_IsOK(res1)) {
6407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6408 }
6409 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (bool)((wxGridCellAttr const *)arg1)->HasFont();
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 {
6417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6418 }
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 SWIGINTERN PyObject *_wrap_GridCellAttr_HasAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6426 PyObject *resultobj = 0;
6427 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6428 bool result;
6429 void *argp1 = 0 ;
6430 int res1 = 0 ;
6431 PyObject *swig_obj[1] ;
6432
6433 if (!args) SWIG_fail;
6434 swig_obj[0] = args;
6435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6436 if (!SWIG_IsOK(res1)) {
6437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6438 }
6439 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6440 {
6441 PyThreadState* __tstate = wxPyBeginAllowThreads();
6442 result = (bool)((wxGridCellAttr const *)arg1)->HasAlignment();
6443 wxPyEndAllowThreads(__tstate);
6444 if (PyErr_Occurred()) SWIG_fail;
6445 }
6446 {
6447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6448 }
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 SWIGINTERN PyObject *_wrap_GridCellAttr_HasRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6456 PyObject *resultobj = 0;
6457 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6458 bool result;
6459 void *argp1 = 0 ;
6460 int res1 = 0 ;
6461 PyObject *swig_obj[1] ;
6462
6463 if (!args) SWIG_fail;
6464 swig_obj[0] = args;
6465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6466 if (!SWIG_IsOK(res1)) {
6467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6468 }
6469 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 result = (bool)((wxGridCellAttr const *)arg1)->HasRenderer();
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 {
6477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6478 }
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 SWIGINTERN PyObject *_wrap_GridCellAttr_HasEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6486 PyObject *resultobj = 0;
6487 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6488 bool result;
6489 void *argp1 = 0 ;
6490 int res1 = 0 ;
6491 PyObject *swig_obj[1] ;
6492
6493 if (!args) SWIG_fail;
6494 swig_obj[0] = args;
6495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6496 if (!SWIG_IsOK(res1)) {
6497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6498 }
6499 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6500 {
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (bool)((wxGridCellAttr const *)arg1)->HasEditor();
6503 wxPyEndAllowThreads(__tstate);
6504 if (PyErr_Occurred()) SWIG_fail;
6505 }
6506 {
6507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6508 }
6509 return resultobj;
6510 fail:
6511 return NULL;
6512 }
6513
6514
6515 SWIGINTERN PyObject *_wrap_GridCellAttr_HasReadWriteMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6516 PyObject *resultobj = 0;
6517 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6518 bool result;
6519 void *argp1 = 0 ;
6520 int res1 = 0 ;
6521 PyObject *swig_obj[1] ;
6522
6523 if (!args) SWIG_fail;
6524 swig_obj[0] = args;
6525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6526 if (!SWIG_IsOK(res1)) {
6527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasReadWriteMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6528 }
6529 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6530 {
6531 PyThreadState* __tstate = wxPyBeginAllowThreads();
6532 result = (bool)((wxGridCellAttr const *)arg1)->HasReadWriteMode();
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 {
6537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6538 }
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 SWIGINTERN PyObject *_wrap_GridCellAttr_HasOverflowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6546 PyObject *resultobj = 0;
6547 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6548 bool result;
6549 void *argp1 = 0 ;
6550 int res1 = 0 ;
6551 PyObject *swig_obj[1] ;
6552
6553 if (!args) SWIG_fail;
6554 swig_obj[0] = args;
6555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6556 if (!SWIG_IsOK(res1)) {
6557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_HasOverflowMode" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6558 }
6559 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6560 {
6561 PyThreadState* __tstate = wxPyBeginAllowThreads();
6562 result = (bool)((wxGridCellAttr const *)arg1)->HasOverflowMode();
6563 wxPyEndAllowThreads(__tstate);
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 {
6567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6568 }
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 SWIGINTERN PyObject *_wrap_GridCellAttr_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6576 PyObject *resultobj = 0;
6577 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6578 wxColour result;
6579 void *argp1 = 0 ;
6580 int res1 = 0 ;
6581 PyObject *swig_obj[1] ;
6582
6583 if (!args) SWIG_fail;
6584 swig_obj[0] = args;
6585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6586 if (!SWIG_IsOK(res1)) {
6587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetTextColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6588 }
6589 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 result = ((wxGridCellAttr const *)arg1)->GetTextColour();
6593 wxPyEndAllowThreads(__tstate);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6597 return resultobj;
6598 fail:
6599 return NULL;
6600 }
6601
6602
6603 SWIGINTERN PyObject *_wrap_GridCellAttr_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6604 PyObject *resultobj = 0;
6605 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6606 wxColour result;
6607 void *argp1 = 0 ;
6608 int res1 = 0 ;
6609 PyObject *swig_obj[1] ;
6610
6611 if (!args) SWIG_fail;
6612 swig_obj[0] = args;
6613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6614 if (!SWIG_IsOK(res1)) {
6615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetBackgroundColour" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6616 }
6617 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 result = ((wxGridCellAttr const *)arg1)->GetBackgroundColour();
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
6625 return resultobj;
6626 fail:
6627 return NULL;
6628 }
6629
6630
6631 SWIGINTERN PyObject *_wrap_GridCellAttr_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6632 PyObject *resultobj = 0;
6633 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6634 wxFont result;
6635 void *argp1 = 0 ;
6636 int res1 = 0 ;
6637 PyObject *swig_obj[1] ;
6638
6639 if (!args) SWIG_fail;
6640 swig_obj[0] = args;
6641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6642 if (!SWIG_IsOK(res1)) {
6643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetFont" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6644 }
6645 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 result = ((wxGridCellAttr const *)arg1)->GetFont();
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
6653 return resultobj;
6654 fail:
6655 return NULL;
6656 }
6657
6658
6659 SWIGINTERN PyObject *_wrap_GridCellAttr_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6660 PyObject *resultobj = 0;
6661 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6662 int *arg2 = (int *) 0 ;
6663 int *arg3 = (int *) 0 ;
6664 void *argp1 = 0 ;
6665 int res1 = 0 ;
6666 int temp2 ;
6667 int res2 = SWIG_TMPOBJ ;
6668 int temp3 ;
6669 int res3 = SWIG_TMPOBJ ;
6670 PyObject *swig_obj[1] ;
6671
6672 arg2 = &temp2;
6673 arg3 = &temp3;
6674 if (!args) SWIG_fail;
6675 swig_obj[0] = args;
6676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6677 if (!SWIG_IsOK(res1)) {
6678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetAlignment" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6679 }
6680 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6681 {
6682 PyThreadState* __tstate = wxPyBeginAllowThreads();
6683 ((wxGridCellAttr const *)arg1)->GetAlignment(arg2,arg3);
6684 wxPyEndAllowThreads(__tstate);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 resultobj = SWIG_Py_Void();
6688 if (SWIG_IsTmpObj(res2)) {
6689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6690 } else {
6691 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6693 }
6694 if (SWIG_IsTmpObj(res3)) {
6695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6696 } else {
6697 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6699 }
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 SWIGINTERN PyObject *_wrap_GridCellAttr_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6707 PyObject *resultobj = 0;
6708 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6709 int *arg2 = (int *) 0 ;
6710 int *arg3 = (int *) 0 ;
6711 void *argp1 = 0 ;
6712 int res1 = 0 ;
6713 int temp2 ;
6714 int res2 = SWIG_TMPOBJ ;
6715 int temp3 ;
6716 int res3 = SWIG_TMPOBJ ;
6717 PyObject *swig_obj[1] ;
6718
6719 arg2 = &temp2;
6720 arg3 = &temp3;
6721 if (!args) SWIG_fail;
6722 swig_obj[0] = args;
6723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetSize" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6726 }
6727 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6728 {
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 ((wxGridCellAttr const *)arg1)->GetSize(arg2,arg3);
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_Py_Void();
6735 if (SWIG_IsTmpObj(res2)) {
6736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6737 } else {
6738 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6740 }
6741 if (SWIG_IsTmpObj(res3)) {
6742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6743 } else {
6744 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6746 }
6747 return resultobj;
6748 fail:
6749 return NULL;
6750 }
6751
6752
6753 SWIGINTERN PyObject *_wrap_GridCellAttr_GetOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6754 PyObject *resultobj = 0;
6755 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6756 bool result;
6757 void *argp1 = 0 ;
6758 int res1 = 0 ;
6759 PyObject *swig_obj[1] ;
6760
6761 if (!args) SWIG_fail;
6762 swig_obj[0] = args;
6763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6764 if (!SWIG_IsOK(res1)) {
6765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetOverflow" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6766 }
6767 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6768 {
6769 PyThreadState* __tstate = wxPyBeginAllowThreads();
6770 result = (bool)((wxGridCellAttr const *)arg1)->GetOverflow();
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 SWIGINTERN PyObject *_wrap_GridCellAttr_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6784 PyObject *resultobj = 0;
6785 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6786 wxGrid *arg2 = (wxGrid *) 0 ;
6787 int arg3 ;
6788 int arg4 ;
6789 wxGridCellRenderer *result = 0 ;
6790 void *argp1 = 0 ;
6791 int res1 = 0 ;
6792 void *argp2 = 0 ;
6793 int res2 = 0 ;
6794 int val3 ;
6795 int ecode3 = 0 ;
6796 int val4 ;
6797 int ecode4 = 0 ;
6798 PyObject * obj0 = 0 ;
6799 PyObject * obj1 = 0 ;
6800 PyObject * obj2 = 0 ;
6801 PyObject * obj3 = 0 ;
6802 char * kwnames[] = {
6803 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6804 };
6805
6806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6808 if (!SWIG_IsOK(res1)) {
6809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6810 }
6811 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6813 if (!SWIG_IsOK(res2)) {
6814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "2"" of type '" "wxGrid *""'");
6815 }
6816 arg2 = reinterpret_cast< wxGrid * >(argp2);
6817 ecode3 = SWIG_AsVal_int(obj2, &val3);
6818 if (!SWIG_IsOK(ecode3)) {
6819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "3"" of type '" "int""'");
6820 }
6821 arg3 = static_cast< int >(val3);
6822 ecode4 = SWIG_AsVal_int(obj3, &val4);
6823 if (!SWIG_IsOK(ecode4)) {
6824 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetRenderer" "', expected argument " "4"" of type '" "int""'");
6825 }
6826 arg4 = static_cast< int >(val4);
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (wxGridCellRenderer *)((wxGridCellAttr const *)arg1)->GetRenderer(arg2,arg3,arg4);
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 {
6834 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
6835 }
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 SWIGINTERN PyObject *_wrap_GridCellAttr_GetEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6843 PyObject *resultobj = 0;
6844 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6845 wxGrid *arg2 = (wxGrid *) 0 ;
6846 int arg3 ;
6847 int arg4 ;
6848 wxGridCellEditor *result = 0 ;
6849 void *argp1 = 0 ;
6850 int res1 = 0 ;
6851 void *argp2 = 0 ;
6852 int res2 = 0 ;
6853 int val3 ;
6854 int ecode3 = 0 ;
6855 int val4 ;
6856 int ecode4 = 0 ;
6857 PyObject * obj0 = 0 ;
6858 PyObject * obj1 = 0 ;
6859 PyObject * obj2 = 0 ;
6860 PyObject * obj3 = 0 ;
6861 char * kwnames[] = {
6862 (char *) "self",(char *) "grid",(char *) "row",(char *) "col", NULL
6863 };
6864
6865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttr_GetEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetEditor" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
6872 if (!SWIG_IsOK(res2)) {
6873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_GetEditor" "', expected argument " "2"" of type '" "wxGrid *""'");
6874 }
6875 arg2 = reinterpret_cast< wxGrid * >(argp2);
6876 ecode3 = SWIG_AsVal_int(obj2, &val3);
6877 if (!SWIG_IsOK(ecode3)) {
6878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttr_GetEditor" "', expected argument " "3"" of type '" "int""'");
6879 }
6880 arg3 = static_cast< int >(val3);
6881 ecode4 = SWIG_AsVal_int(obj3, &val4);
6882 if (!SWIG_IsOK(ecode4)) {
6883 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttr_GetEditor" "', expected argument " "4"" of type '" "int""'");
6884 }
6885 arg4 = static_cast< int >(val4);
6886 {
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 result = (wxGridCellEditor *)((wxGridCellAttr const *)arg1)->GetEditor(arg2,arg3,arg4);
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 {
6893 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
6894 }
6895 return resultobj;
6896 fail:
6897 return NULL;
6898 }
6899
6900
6901 SWIGINTERN PyObject *_wrap_GridCellAttr_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6902 PyObject *resultobj = 0;
6903 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6904 bool result;
6905 void *argp1 = 0 ;
6906 int res1 = 0 ;
6907 PyObject *swig_obj[1] ;
6908
6909 if (!args) SWIG_fail;
6910 swig_obj[0] = args;
6911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6912 if (!SWIG_IsOK(res1)) {
6913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_IsReadOnly" "', expected argument " "1"" of type '" "wxGridCellAttr const *""'");
6914 }
6915 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6916 {
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 result = (bool)((wxGridCellAttr const *)arg1)->IsReadOnly();
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 {
6923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6924 }
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 SWIGINTERN PyObject *_wrap_GridCellAttr_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6932 PyObject *resultobj = 0;
6933 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6934 wxGridCellAttr::wxAttrKind result;
6935 void *argp1 = 0 ;
6936 int res1 = 0 ;
6937 PyObject *swig_obj[1] ;
6938
6939 if (!args) SWIG_fail;
6940 swig_obj[0] = args;
6941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6942 if (!SWIG_IsOK(res1)) {
6943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_GetKind" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6944 }
6945 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6946 {
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 result = (wxGridCellAttr::wxAttrKind)(arg1)->GetKind();
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 resultobj = SWIG_From_int(static_cast< int >(result));
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 SWIGINTERN PyObject *_wrap_GridCellAttr_SetDefAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6960 PyObject *resultobj = 0;
6961 wxGridCellAttr *arg1 = (wxGridCellAttr *) 0 ;
6962 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
6963 void *argp1 = 0 ;
6964 int res1 = 0 ;
6965 void *argp2 = 0 ;
6966 int res2 = 0 ;
6967 PyObject * obj0 = 0 ;
6968 PyObject * obj1 = 0 ;
6969 char * kwnames[] = {
6970 (char *) "self",(char *) "defAttr", NULL
6971 };
6972
6973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttr_SetDefAttr",kwnames,&obj0,&obj1)) SWIG_fail;
6974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "1"" of type '" "wxGridCellAttr *""'");
6977 }
6978 arg1 = reinterpret_cast< wxGridCellAttr * >(argp1);
6979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
6980 if (!SWIG_IsOK(res2)) {
6981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttr_SetDefAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
6982 }
6983 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 (arg1)->SetDefAttr(arg2);
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 resultobj = SWIG_Py_Void();
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 SWIGINTERN PyObject *GridCellAttr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6998 PyObject *obj;
6999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7000 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttr, SWIG_NewClientData(obj));
7001 return SWIG_Py_Void();
7002 }
7003
7004 SWIGINTERN PyObject *GridCellAttr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7005 return SWIG_Python_InitShadowInstance(args);
7006 }
7007
7008 SWIGINTERN PyObject *_wrap_new_GridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 PyObject *resultobj = 0;
7010 wxGridCellAttrProvider *result = 0 ;
7011
7012 if (!SWIG_Python_UnpackTuple(args,"new_GridCellAttrProvider",0,0,0)) SWIG_fail;
7013 {
7014 PyThreadState* __tstate = wxPyBeginAllowThreads();
7015 result = (wxGridCellAttrProvider *)new wxGridCellAttrProvider();
7016 wxPyEndAllowThreads(__tstate);
7017 if (PyErr_Occurred()) SWIG_fail;
7018 }
7019 {
7020 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)SWIG_POINTER_NEW);
7021 }
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 SWIGINTERN PyObject *_wrap_GridCellAttrProvider__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7029 PyObject *resultobj = 0;
7030 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7031 PyObject *arg2 = (PyObject *) 0 ;
7032 void *argp1 = 0 ;
7033 int res1 = 0 ;
7034 PyObject * obj0 = 0 ;
7035 PyObject * obj1 = 0 ;
7036 char * kwnames[] = {
7037 (char *) "self",(char *) "_self", NULL
7038 };
7039
7040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellAttrProvider__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7042 if (!SWIG_IsOK(res1)) {
7043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider__setOORInfo" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7044 }
7045 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7046 arg2 = obj1;
7047 {
7048 PyThreadState* __tstate = wxPyBeginAllowThreads();
7049 wxGridCellAttrProvider__setOORInfo(arg1,arg2);
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_Py_Void();
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj = 0;
7062 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7063 int arg2 ;
7064 int arg3 ;
7065 wxGridCellAttr::wxAttrKind arg4 ;
7066 wxGridCellAttr *result = 0 ;
7067 void *argp1 = 0 ;
7068 int res1 = 0 ;
7069 int val2 ;
7070 int ecode2 = 0 ;
7071 int val3 ;
7072 int ecode3 = 0 ;
7073 int val4 ;
7074 int ecode4 = 0 ;
7075 PyObject * obj0 = 0 ;
7076 PyObject * obj1 = 0 ;
7077 PyObject * obj2 = 0 ;
7078 PyObject * obj3 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider const *""'");
7087 }
7088 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7089 ecode2 = SWIG_AsVal_int(obj1, &val2);
7090 if (!SWIG_IsOK(ecode2)) {
7091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7092 }
7093 arg2 = static_cast< int >(val2);
7094 ecode3 = SWIG_AsVal_int(obj2, &val3);
7095 if (!SWIG_IsOK(ecode3)) {
7096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7097 }
7098 arg3 = static_cast< int >(val3);
7099 ecode4 = SWIG_AsVal_int(obj3, &val4);
7100 if (!SWIG_IsOK(ecode4)) {
7101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7102 }
7103 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7104 {
7105 PyThreadState* __tstate = wxPyBeginAllowThreads();
7106 result = (wxGridCellAttr *)((wxGridCellAttrProvider const *)arg1)->GetAttr(arg2,arg3,arg4);
7107 wxPyEndAllowThreads(__tstate);
7108 if (PyErr_Occurred()) SWIG_fail;
7109 }
7110 {
7111 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7112 }
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7120 PyObject *resultobj = 0;
7121 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7122 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7123 int arg3 ;
7124 int arg4 ;
7125 void *argp1 = 0 ;
7126 int res1 = 0 ;
7127 void *argp2 = 0 ;
7128 int res2 = 0 ;
7129 int val3 ;
7130 int ecode3 = 0 ;
7131 int val4 ;
7132 int ecode4 = 0 ;
7133 PyObject * obj0 = 0 ;
7134 PyObject * obj1 = 0 ;
7135 PyObject * obj2 = 0 ;
7136 PyObject * obj3 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7145 }
7146 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7148 if (!SWIG_IsOK(res2)) {
7149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7150 }
7151 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7152 ecode3 = SWIG_AsVal_int(obj2, &val3);
7153 if (!SWIG_IsOK(ecode3)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7155 }
7156 arg3 = static_cast< int >(val3);
7157 ecode4 = SWIG_AsVal_int(obj3, &val4);
7158 if (!SWIG_IsOK(ecode4)) {
7159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7160 }
7161 arg4 = static_cast< int >(val4);
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 (arg1)->SetAttr(arg2,arg3,arg4);
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 resultobj = SWIG_Py_Void();
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj = 0;
7177 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7178 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7179 int arg3 ;
7180 void *argp1 = 0 ;
7181 int res1 = 0 ;
7182 void *argp2 = 0 ;
7183 int res2 = 0 ;
7184 int val3 ;
7185 int ecode3 = 0 ;
7186 PyObject * obj0 = 0 ;
7187 PyObject * obj1 = 0 ;
7188 PyObject * obj2 = 0 ;
7189 char * kwnames[] = {
7190 (char *) "self",(char *) "attr",(char *) "row", NULL
7191 };
7192
7193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7195 if (!SWIG_IsOK(res1)) {
7196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7197 }
7198 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7200 if (!SWIG_IsOK(res2)) {
7201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7202 }
7203 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7204 ecode3 = SWIG_AsVal_int(obj2, &val3);
7205 if (!SWIG_IsOK(ecode3)) {
7206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7207 }
7208 arg3 = static_cast< int >(val3);
7209 {
7210 PyThreadState* __tstate = wxPyBeginAllowThreads();
7211 (arg1)->SetRowAttr(arg2,arg3);
7212 wxPyEndAllowThreads(__tstate);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 resultobj = SWIG_Py_Void();
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj = 0;
7224 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7225 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7226 int arg3 ;
7227 void *argp1 = 0 ;
7228 int res1 = 0 ;
7229 void *argp2 = 0 ;
7230 int res2 = 0 ;
7231 int val3 ;
7232 int ecode3 = 0 ;
7233 PyObject * obj0 = 0 ;
7234 PyObject * obj1 = 0 ;
7235 PyObject * obj2 = 0 ;
7236 char * kwnames[] = {
7237 (char *) "self",(char *) "attr",(char *) "col", NULL
7238 };
7239
7240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7242 if (!SWIG_IsOK(res1)) {
7243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7244 }
7245 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7246 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7247 if (!SWIG_IsOK(res2)) {
7248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7249 }
7250 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7251 ecode3 = SWIG_AsVal_int(obj2, &val3);
7252 if (!SWIG_IsOK(ecode3)) {
7253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7254 }
7255 arg3 = static_cast< int >(val3);
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 (arg1)->SetColAttr(arg2,arg3);
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 resultobj = SWIG_Py_Void();
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj = 0;
7271 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7272 size_t arg2 ;
7273 int arg3 ;
7274 void *argp1 = 0 ;
7275 int res1 = 0 ;
7276 size_t val2 ;
7277 int ecode2 = 0 ;
7278 int val3 ;
7279 int ecode3 = 0 ;
7280 PyObject * obj0 = 0 ;
7281 PyObject * obj1 = 0 ;
7282 PyObject * obj2 = 0 ;
7283 char * kwnames[] = {
7284 (char *) "self",(char *) "pos",(char *) "numRows", NULL
7285 };
7286
7287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7289 if (!SWIG_IsOK(res1)) {
7290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7291 }
7292 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7293 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7294 if (!SWIG_IsOK(ecode2)) {
7295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "2"" of type '" "size_t""'");
7296 }
7297 arg2 = static_cast< size_t >(val2);
7298 ecode3 = SWIG_AsVal_int(obj2, &val3);
7299 if (!SWIG_IsOK(ecode3)) {
7300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrRows" "', expected argument " "3"" of type '" "int""'");
7301 }
7302 arg3 = static_cast< int >(val3);
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->UpdateAttrRows(arg2,arg3);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_Py_Void();
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_GridCellAttrProvider_UpdateAttrCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxGridCellAttrProvider *arg1 = (wxGridCellAttrProvider *) 0 ;
7319 size_t arg2 ;
7320 int arg3 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 size_t val2 ;
7324 int ecode2 = 0 ;
7325 int val3 ;
7326 int ecode3 = 0 ;
7327 PyObject * obj0 = 0 ;
7328 PyObject * obj1 = 0 ;
7329 PyObject * obj2 = 0 ;
7330 char * kwnames[] = {
7331 (char *) "self",(char *) "pos",(char *) "numCols", NULL
7332 };
7333
7334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellAttrProvider_UpdateAttrCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7336 if (!SWIG_IsOK(res1)) {
7337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "1"" of type '" "wxGridCellAttrProvider *""'");
7338 }
7339 arg1 = reinterpret_cast< wxGridCellAttrProvider * >(argp1);
7340 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7341 if (!SWIG_IsOK(ecode2)) {
7342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "2"" of type '" "size_t""'");
7343 }
7344 arg2 = static_cast< size_t >(val2);
7345 ecode3 = SWIG_AsVal_int(obj2, &val3);
7346 if (!SWIG_IsOK(ecode3)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellAttrProvider_UpdateAttrCols" "', expected argument " "3"" of type '" "int""'");
7348 }
7349 arg3 = static_cast< int >(val3);
7350 {
7351 PyThreadState* __tstate = wxPyBeginAllowThreads();
7352 (arg1)->UpdateAttrCols(arg2,arg3);
7353 wxPyEndAllowThreads(__tstate);
7354 if (PyErr_Occurred()) SWIG_fail;
7355 }
7356 resultobj = SWIG_Py_Void();
7357 return resultobj;
7358 fail:
7359 return NULL;
7360 }
7361
7362
7363 SWIGINTERN PyObject *GridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7364 PyObject *obj;
7365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7366 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellAttrProvider, SWIG_NewClientData(obj));
7367 return SWIG_Py_Void();
7368 }
7369
7370 SWIGINTERN PyObject *GridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7371 return SWIG_Python_InitShadowInstance(args);
7372 }
7373
7374 SWIGINTERN PyObject *_wrap_new_PyGridCellAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7375 PyObject *resultobj = 0;
7376 wxPyGridCellAttrProvider *result = 0 ;
7377
7378 if (!SWIG_Python_UnpackTuple(args,"new_PyGridCellAttrProvider",0,0,0)) SWIG_fail;
7379 {
7380 PyThreadState* __tstate = wxPyBeginAllowThreads();
7381 result = (wxPyGridCellAttrProvider *)new wxPyGridCellAttrProvider();
7382 wxPyEndAllowThreads(__tstate);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_POINTER_NEW | 0 );
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj = 0;
7394 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7395 PyObject *arg2 = (PyObject *) 0 ;
7396 PyObject *arg3 = (PyObject *) 0 ;
7397 void *argp1 = 0 ;
7398 int res1 = 0 ;
7399 PyObject * obj0 = 0 ;
7400 PyObject * obj1 = 0 ;
7401 PyObject * obj2 = 0 ;
7402 char * kwnames[] = {
7403 (char *) "self",(char *) "self",(char *) "_class", NULL
7404 };
7405
7406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7408 if (!SWIG_IsOK(res1)) {
7409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7410 }
7411 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7412 arg2 = obj1;
7413 arg3 = obj2;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->_setCallbackInfo(arg2,arg3);
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 resultobj = SWIG_Py_Void();
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj = 0;
7429 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7430 int arg2 ;
7431 int arg3 ;
7432 wxGridCellAttr::wxAttrKind arg4 ;
7433 wxGridCellAttr *result = 0 ;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 int val2 ;
7437 int ecode2 = 0 ;
7438 int val3 ;
7439 int ecode3 = 0 ;
7440 int val4 ;
7441 int ecode4 = 0 ;
7442 PyObject * obj0 = 0 ;
7443 PyObject * obj1 = 0 ;
7444 PyObject * obj2 = 0 ;
7445 PyObject * obj3 = 0 ;
7446 char * kwnames[] = {
7447 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
7448 };
7449
7450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7452 if (!SWIG_IsOK(res1)) {
7453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7454 }
7455 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7456 ecode2 = SWIG_AsVal_int(obj1, &val2);
7457 if (!SWIG_IsOK(ecode2)) {
7458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "2"" of type '" "int""'");
7459 }
7460 arg2 = static_cast< int >(val2);
7461 ecode3 = SWIG_AsVal_int(obj2, &val3);
7462 if (!SWIG_IsOK(ecode3)) {
7463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "3"" of type '" "int""'");
7464 }
7465 arg3 = static_cast< int >(val3);
7466 ecode4 = SWIG_AsVal_int(obj3, &val4);
7467 if (!SWIG_IsOK(ecode4)) {
7468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
7469 }
7470 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 {
7478 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
7479 }
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj = 0;
7488 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7489 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7490 int arg3 ;
7491 int arg4 ;
7492 void *argp1 = 0 ;
7493 int res1 = 0 ;
7494 void *argp2 = 0 ;
7495 int res2 = 0 ;
7496 int val3 ;
7497 int ecode3 = 0 ;
7498 int val4 ;
7499 int ecode4 = 0 ;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 PyObject * obj2 = 0 ;
7503 PyObject * obj3 = 0 ;
7504 char * kwnames[] = {
7505 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
7506 };
7507
7508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyGridCellAttrProvider_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7510 if (!SWIG_IsOK(res1)) {
7511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7512 }
7513 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7515 if (!SWIG_IsOK(res2)) {
7516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7517 }
7518 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7519 ecode3 = SWIG_AsVal_int(obj2, &val3);
7520 if (!SWIG_IsOK(ecode3)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "3"" of type '" "int""'");
7522 }
7523 arg3 = static_cast< int >(val3);
7524 ecode4 = SWIG_AsVal_int(obj3, &val4);
7525 if (!SWIG_IsOK(ecode4)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyGridCellAttrProvider_SetAttr" "', expected argument " "4"" of type '" "int""'");
7527 }
7528 arg4 = static_cast< int >(val4);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 (arg1)->SetAttr(arg2,arg3,arg4);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 resultobj = SWIG_Py_Void();
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7543 PyObject *resultobj = 0;
7544 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7545 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7546 int arg3 ;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 void *argp2 = 0 ;
7550 int res2 = 0 ;
7551 int val3 ;
7552 int ecode3 = 0 ;
7553 PyObject * obj0 = 0 ;
7554 PyObject * obj1 = 0 ;
7555 PyObject * obj2 = 0 ;
7556 char * kwnames[] = {
7557 (char *) "self",(char *) "attr",(char *) "row", NULL
7558 };
7559
7560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7562 if (!SWIG_IsOK(res1)) {
7563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7564 }
7565 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7567 if (!SWIG_IsOK(res2)) {
7568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7569 }
7570 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7571 ecode3 = SWIG_AsVal_int(obj2, &val3);
7572 if (!SWIG_IsOK(ecode3)) {
7573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
7574 }
7575 arg3 = static_cast< int >(val3);
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 (arg1)->SetRowAttr(arg2,arg3);
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_Py_Void();
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_PyGridCellAttrProvider_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj = 0;
7591 wxPyGridCellAttrProvider *arg1 = (wxPyGridCellAttrProvider *) 0 ;
7592 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
7593 int arg3 ;
7594 void *argp1 = 0 ;
7595 int res1 = 0 ;
7596 void *argp2 = 0 ;
7597 int res2 = 0 ;
7598 int val3 ;
7599 int ecode3 = 0 ;
7600 PyObject * obj0 = 0 ;
7601 PyObject * obj1 = 0 ;
7602 PyObject * obj2 = 0 ;
7603 char * kwnames[] = {
7604 (char *) "self",(char *) "attr",(char *) "col", NULL
7605 };
7606
7607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridCellAttrProvider_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridCellAttrProvider, 0 | 0 );
7609 if (!SWIG_IsOK(res1)) {
7610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "1"" of type '" "wxPyGridCellAttrProvider *""'");
7611 }
7612 arg1 = reinterpret_cast< wxPyGridCellAttrProvider * >(argp1);
7613 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
7614 if (!SWIG_IsOK(res2)) {
7615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
7616 }
7617 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
7618 ecode3 = SWIG_AsVal_int(obj2, &val3);
7619 if (!SWIG_IsOK(ecode3)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyGridCellAttrProvider_SetColAttr" "', expected argument " "3"" of type '" "int""'");
7621 }
7622 arg3 = static_cast< int >(val3);
7623 {
7624 PyThreadState* __tstate = wxPyBeginAllowThreads();
7625 (arg1)->SetColAttr(arg2,arg3);
7626 wxPyEndAllowThreads(__tstate);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 resultobj = SWIG_Py_Void();
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *PyGridCellAttrProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *obj;
7638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridCellAttrProvider, SWIG_NewClientData(obj));
7640 return SWIG_Py_Void();
7641 }
7642
7643 SWIGINTERN PyObject *PyGridCellAttrProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7644 return SWIG_Python_InitShadowInstance(args);
7645 }
7646
7647 SWIGINTERN PyObject *_wrap_delete_GridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7648 PyObject *resultobj = 0;
7649 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7650 void *argp1 = 0 ;
7651 int res1 = 0 ;
7652 PyObject *swig_obj[1] ;
7653
7654 if (!args) SWIG_fail;
7655 swig_obj[0] = args;
7656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
7657 if (!SWIG_IsOK(res1)) {
7658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableBase" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7659 }
7660 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7661 {
7662 PyThreadState* __tstate = wxPyBeginAllowThreads();
7663 delete arg1;
7664
7665 wxPyEndAllowThreads(__tstate);
7666 if (PyErr_Occurred()) SWIG_fail;
7667 }
7668 resultobj = SWIG_Py_Void();
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 SWIGINTERN PyObject *_wrap_GridTableBase__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7676 PyObject *resultobj = 0;
7677 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7678 PyObject *arg2 = (PyObject *) 0 ;
7679 void *argp1 = 0 ;
7680 int res1 = 0 ;
7681 PyObject * obj0 = 0 ;
7682 PyObject * obj1 = 0 ;
7683 char * kwnames[] = {
7684 (char *) "self",(char *) "_self", NULL
7685 };
7686
7687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
7688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7689 if (!SWIG_IsOK(res1)) {
7690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase__setOORInfo" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7691 }
7692 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7693 arg2 = obj1;
7694 {
7695 PyThreadState* __tstate = wxPyBeginAllowThreads();
7696 wxGridTableBase__setOORInfo(arg1,arg2);
7697 wxPyEndAllowThreads(__tstate);
7698 if (PyErr_Occurred()) SWIG_fail;
7699 }
7700 resultobj = SWIG_Py_Void();
7701 return resultobj;
7702 fail:
7703 return NULL;
7704 }
7705
7706
7707 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7708 PyObject *resultobj = 0;
7709 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7710 wxGridCellAttrProvider *arg2 = (wxGridCellAttrProvider *) 0 ;
7711 void *argp1 = 0 ;
7712 int res1 = 0 ;
7713 void *argp2 = 0 ;
7714 int res2 = 0 ;
7715 PyObject * obj0 = 0 ;
7716 PyObject * obj1 = 0 ;
7717 char * kwnames[] = {
7718 (char *) "self",(char *) "attrProvider", NULL
7719 };
7720
7721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetAttrProvider",kwnames,&obj0,&obj1)) SWIG_fail;
7722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7723 if (!SWIG_IsOK(res1)) {
7724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7725 }
7726 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttrProvider, 0 | 0 );
7728 if (!SWIG_IsOK(res2)) {
7729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttrProvider" "', expected argument " "2"" of type '" "wxGridCellAttrProvider *""'");
7730 }
7731 arg2 = reinterpret_cast< wxGridCellAttrProvider * >(argp2);
7732 {
7733 PyThreadState* __tstate = wxPyBeginAllowThreads();
7734 (arg1)->SetAttrProvider(arg2);
7735 wxPyEndAllowThreads(__tstate);
7736 if (PyErr_Occurred()) SWIG_fail;
7737 }
7738 resultobj = SWIG_Py_Void();
7739 return resultobj;
7740 fail:
7741 return NULL;
7742 }
7743
7744
7745 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttrProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7746 PyObject *resultobj = 0;
7747 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7748 wxGridCellAttrProvider *result = 0 ;
7749 void *argp1 = 0 ;
7750 int res1 = 0 ;
7751 PyObject *swig_obj[1] ;
7752
7753 if (!args) SWIG_fail;
7754 swig_obj[0] = args;
7755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7756 if (!SWIG_IsOK(res1)) {
7757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttrProvider" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7758 }
7759 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 result = (wxGridCellAttrProvider *)((wxGridTableBase const *)arg1)->GetAttrProvider();
7763 wxPyEndAllowThreads(__tstate);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 {
7767 resultobj = wxPyMake_wxGridCellAttrProvider(result, (bool)0);
7768 }
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 SWIGINTERN PyObject *_wrap_GridTableBase_SetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj = 0;
7777 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7778 wxGrid *arg2 = (wxGrid *) 0 ;
7779 void *argp1 = 0 ;
7780 int res1 = 0 ;
7781 void *argp2 = 0 ;
7782 int res2 = 0 ;
7783 PyObject * obj0 = 0 ;
7784 PyObject * obj1 = 0 ;
7785 char * kwnames[] = {
7786 (char *) "self",(char *) "grid", NULL
7787 };
7788
7789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_SetView",kwnames,&obj0,&obj1)) SWIG_fail;
7790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7791 if (!SWIG_IsOK(res1)) {
7792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetView" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7793 }
7794 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGrid, 0 | 0 );
7796 if (!SWIG_IsOK(res2)) {
7797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetView" "', expected argument " "2"" of type '" "wxGrid *""'");
7798 }
7799 arg2 = reinterpret_cast< wxGrid * >(argp2);
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 (arg1)->SetView(arg2);
7803 wxPyEndAllowThreads(__tstate);
7804 if (PyErr_Occurred()) SWIG_fail;
7805 }
7806 resultobj = SWIG_Py_Void();
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 SWIGINTERN PyObject *_wrap_GridTableBase_GetView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7814 PyObject *resultobj = 0;
7815 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7816 wxGrid *result = 0 ;
7817 void *argp1 = 0 ;
7818 int res1 = 0 ;
7819 PyObject *swig_obj[1] ;
7820
7821 if (!args) SWIG_fail;
7822 swig_obj[0] = args;
7823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7824 if (!SWIG_IsOK(res1)) {
7825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetView" "', expected argument " "1"" of type '" "wxGridTableBase const *""'");
7826 }
7827 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7828 {
7829 PyThreadState* __tstate = wxPyBeginAllowThreads();
7830 result = (wxGrid *)((wxGridTableBase const *)arg1)->GetView();
7831 wxPyEndAllowThreads(__tstate);
7832 if (PyErr_Occurred()) SWIG_fail;
7833 }
7834 {
7835 resultobj = wxPyMake_wxObject(result, (bool)0);
7836 }
7837 return resultobj;
7838 fail:
7839 return NULL;
7840 }
7841
7842
7843 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7844 PyObject *resultobj = 0;
7845 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7846 int result;
7847 void *argp1 = 0 ;
7848 int res1 = 0 ;
7849 PyObject *swig_obj[1] ;
7850
7851 if (!args) SWIG_fail;
7852 swig_obj[0] = args;
7853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7854 if (!SWIG_IsOK(res1)) {
7855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7856 }
7857 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7858 {
7859 PyThreadState* __tstate = wxPyBeginAllowThreads();
7860 result = (int)(arg1)->GetNumberRows();
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 resultobj = SWIG_From_int(static_cast< int >(result));
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 SWIGINTERN PyObject *_wrap_GridTableBase_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7872 PyObject *resultobj = 0;
7873 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7874 int result;
7875 void *argp1 = 0 ;
7876 int res1 = 0 ;
7877 PyObject *swig_obj[1] ;
7878
7879 if (!args) SWIG_fail;
7880 swig_obj[0] = args;
7881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7882 if (!SWIG_IsOK(res1)) {
7883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetNumberCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7884 }
7885 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7886 {
7887 PyThreadState* __tstate = wxPyBeginAllowThreads();
7888 result = (int)(arg1)->GetNumberCols();
7889 wxPyEndAllowThreads(__tstate);
7890 if (PyErr_Occurred()) SWIG_fail;
7891 }
7892 resultobj = SWIG_From_int(static_cast< int >(result));
7893 return resultobj;
7894 fail:
7895 return NULL;
7896 }
7897
7898
7899 SWIGINTERN PyObject *_wrap_GridTableBase_IsEmptyCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7900 PyObject *resultobj = 0;
7901 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7902 int arg2 ;
7903 int arg3 ;
7904 bool result;
7905 void *argp1 = 0 ;
7906 int res1 = 0 ;
7907 int val2 ;
7908 int ecode2 = 0 ;
7909 int val3 ;
7910 int ecode3 = 0 ;
7911 PyObject * obj0 = 0 ;
7912 PyObject * obj1 = 0 ;
7913 PyObject * obj2 = 0 ;
7914 char * kwnames[] = {
7915 (char *) "self",(char *) "row",(char *) "col", NULL
7916 };
7917
7918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_IsEmptyCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7920 if (!SWIG_IsOK(res1)) {
7921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7922 }
7923 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7924 ecode2 = SWIG_AsVal_int(obj1, &val2);
7925 if (!SWIG_IsOK(ecode2)) {
7926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "2"" of type '" "int""'");
7927 }
7928 arg2 = static_cast< int >(val2);
7929 ecode3 = SWIG_AsVal_int(obj2, &val3);
7930 if (!SWIG_IsOK(ecode3)) {
7931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_IsEmptyCell" "', expected argument " "3"" of type '" "int""'");
7932 }
7933 arg3 = static_cast< int >(val3);
7934 {
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (bool)(arg1)->IsEmptyCell(arg2,arg3);
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 {
7941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7942 }
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 SWIGINTERN PyObject *_wrap_GridTableBase_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj = 0;
7951 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
7952 int arg2 ;
7953 int arg3 ;
7954 wxString result;
7955 void *argp1 = 0 ;
7956 int res1 = 0 ;
7957 int val2 ;
7958 int ecode2 = 0 ;
7959 int val3 ;
7960 int ecode3 = 0 ;
7961 PyObject * obj0 = 0 ;
7962 PyObject * obj1 = 0 ;
7963 PyObject * obj2 = 0 ;
7964 char * kwnames[] = {
7965 (char *) "self",(char *) "row",(char *) "col", NULL
7966 };
7967
7968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
7970 if (!SWIG_IsOK(res1)) {
7971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
7972 }
7973 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
7974 ecode2 = SWIG_AsVal_int(obj1, &val2);
7975 if (!SWIG_IsOK(ecode2)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValue" "', expected argument " "2"" of type '" "int""'");
7977 }
7978 arg2 = static_cast< int >(val2);
7979 ecode3 = SWIG_AsVal_int(obj2, &val3);
7980 if (!SWIG_IsOK(ecode3)) {
7981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValue" "', expected argument " "3"" of type '" "int""'");
7982 }
7983 arg3 = static_cast< int >(val3);
7984 {
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 result = (arg1)->GetValue(arg2,arg3);
7987 wxPyEndAllowThreads(__tstate);
7988 if (PyErr_Occurred()) SWIG_fail;
7989 }
7990 {
7991 #if wxUSE_UNICODE
7992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7993 #else
7994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7995 #endif
7996 }
7997 return resultobj;
7998 fail:
7999 return NULL;
8000 }
8001
8002
8003 SWIGINTERN PyObject *_wrap_GridTableBase_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8004 PyObject *resultobj = 0;
8005 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8006 int arg2 ;
8007 int arg3 ;
8008 wxString *arg4 = 0 ;
8009 void *argp1 = 0 ;
8010 int res1 = 0 ;
8011 int val2 ;
8012 int ecode2 = 0 ;
8013 int val3 ;
8014 int ecode3 = 0 ;
8015 bool temp4 = false ;
8016 PyObject * obj0 = 0 ;
8017 PyObject * obj1 = 0 ;
8018 PyObject * obj2 = 0 ;
8019 PyObject * obj3 = 0 ;
8020 char * kwnames[] = {
8021 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8022 };
8023
8024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8026 if (!SWIG_IsOK(res1)) {
8027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8028 }
8029 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8030 ecode2 = SWIG_AsVal_int(obj1, &val2);
8031 if (!SWIG_IsOK(ecode2)) {
8032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValue" "', expected argument " "2"" of type '" "int""'");
8033 }
8034 arg2 = static_cast< int >(val2);
8035 ecode3 = SWIG_AsVal_int(obj2, &val3);
8036 if (!SWIG_IsOK(ecode3)) {
8037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValue" "', expected argument " "3"" of type '" "int""'");
8038 }
8039 arg3 = static_cast< int >(val3);
8040 {
8041 arg4 = wxString_in_helper(obj3);
8042 if (arg4 == NULL) SWIG_fail;
8043 temp4 = true;
8044 }
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 (arg1)->SetValue(arg2,arg3,(wxString const &)*arg4);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_Py_Void();
8052 {
8053 if (temp4)
8054 delete arg4;
8055 }
8056 return resultobj;
8057 fail:
8058 {
8059 if (temp4)
8060 delete arg4;
8061 }
8062 return NULL;
8063 }
8064
8065
8066 SWIGINTERN PyObject *_wrap_GridTableBase_GetTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8067 PyObject *resultobj = 0;
8068 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8069 int arg2 ;
8070 int arg3 ;
8071 wxString result;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 int val2 ;
8075 int ecode2 = 0 ;
8076 int val3 ;
8077 int ecode3 = 0 ;
8078 PyObject * obj0 = 0 ;
8079 PyObject * obj1 = 0 ;
8080 PyObject * obj2 = 0 ;
8081 char * kwnames[] = {
8082 (char *) "self",(char *) "row",(char *) "col", NULL
8083 };
8084
8085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetTypeName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8087 if (!SWIG_IsOK(res1)) {
8088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetTypeName" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8089 }
8090 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8091 ecode2 = SWIG_AsVal_int(obj1, &val2);
8092 if (!SWIG_IsOK(ecode2)) {
8093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetTypeName" "', expected argument " "2"" of type '" "int""'");
8094 }
8095 arg2 = static_cast< int >(val2);
8096 ecode3 = SWIG_AsVal_int(obj2, &val3);
8097 if (!SWIG_IsOK(ecode3)) {
8098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetTypeName" "', expected argument " "3"" of type '" "int""'");
8099 }
8100 arg3 = static_cast< int >(val3);
8101 {
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (arg1)->GetTypeName(arg2,arg3);
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 #if wxUSE_UNICODE
8109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8110 #else
8111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8112 #endif
8113 }
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 SWIGINTERN PyObject *_wrap_GridTableBase_CanGetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj = 0;
8122 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8123 int arg2 ;
8124 int arg3 ;
8125 wxString *arg4 = 0 ;
8126 bool result;
8127 void *argp1 = 0 ;
8128 int res1 = 0 ;
8129 int val2 ;
8130 int ecode2 = 0 ;
8131 int val3 ;
8132 int ecode3 = 0 ;
8133 bool temp4 = false ;
8134 PyObject * obj0 = 0 ;
8135 PyObject * obj1 = 0 ;
8136 PyObject * obj2 = 0 ;
8137 PyObject * obj3 = 0 ;
8138 char * kwnames[] = {
8139 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8140 };
8141
8142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanGetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8144 if (!SWIG_IsOK(res1)) {
8145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8146 }
8147 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8148 ecode2 = SWIG_AsVal_int(obj1, &val2);
8149 if (!SWIG_IsOK(ecode2)) {
8150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "2"" of type '" "int""'");
8151 }
8152 arg2 = static_cast< int >(val2);
8153 ecode3 = SWIG_AsVal_int(obj2, &val3);
8154 if (!SWIG_IsOK(ecode3)) {
8155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanGetValueAs" "', expected argument " "3"" of type '" "int""'");
8156 }
8157 arg3 = static_cast< int >(val3);
8158 {
8159 arg4 = wxString_in_helper(obj3);
8160 if (arg4 == NULL) SWIG_fail;
8161 temp4 = true;
8162 }
8163 {
8164 PyThreadState* __tstate = wxPyBeginAllowThreads();
8165 result = (bool)(arg1)->CanGetValueAs(arg2,arg3,(wxString const &)*arg4);
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 {
8170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8171 }
8172 {
8173 if (temp4)
8174 delete arg4;
8175 }
8176 return resultobj;
8177 fail:
8178 {
8179 if (temp4)
8180 delete arg4;
8181 }
8182 return NULL;
8183 }
8184
8185
8186 SWIGINTERN PyObject *_wrap_GridTableBase_CanSetValueAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8187 PyObject *resultobj = 0;
8188 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8189 int arg2 ;
8190 int arg3 ;
8191 wxString *arg4 = 0 ;
8192 bool result;
8193 void *argp1 = 0 ;
8194 int res1 = 0 ;
8195 int val2 ;
8196 int ecode2 = 0 ;
8197 int val3 ;
8198 int ecode3 = 0 ;
8199 bool temp4 = false ;
8200 PyObject * obj0 = 0 ;
8201 PyObject * obj1 = 0 ;
8202 PyObject * obj2 = 0 ;
8203 PyObject * obj3 = 0 ;
8204 char * kwnames[] = {
8205 (char *) "self",(char *) "row",(char *) "col",(char *) "typeName", NULL
8206 };
8207
8208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_CanSetValueAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8210 if (!SWIG_IsOK(res1)) {
8211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8212 }
8213 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8214 ecode2 = SWIG_AsVal_int(obj1, &val2);
8215 if (!SWIG_IsOK(ecode2)) {
8216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "2"" of type '" "int""'");
8217 }
8218 arg2 = static_cast< int >(val2);
8219 ecode3 = SWIG_AsVal_int(obj2, &val3);
8220 if (!SWIG_IsOK(ecode3)) {
8221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_CanSetValueAs" "', expected argument " "3"" of type '" "int""'");
8222 }
8223 arg3 = static_cast< int >(val3);
8224 {
8225 arg4 = wxString_in_helper(obj3);
8226 if (arg4 == NULL) SWIG_fail;
8227 temp4 = true;
8228 }
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 result = (bool)(arg1)->CanSetValueAs(arg2,arg3,(wxString const &)*arg4);
8232 wxPyEndAllowThreads(__tstate);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 {
8236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8237 }
8238 {
8239 if (temp4)
8240 delete arg4;
8241 }
8242 return resultobj;
8243 fail:
8244 {
8245 if (temp4)
8246 delete arg4;
8247 }
8248 return NULL;
8249 }
8250
8251
8252 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj = 0;
8254 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8255 int arg2 ;
8256 int arg3 ;
8257 long result;
8258 void *argp1 = 0 ;
8259 int res1 = 0 ;
8260 int val2 ;
8261 int ecode2 = 0 ;
8262 int val3 ;
8263 int ecode3 = 0 ;
8264 PyObject * obj0 = 0 ;
8265 PyObject * obj1 = 0 ;
8266 PyObject * obj2 = 0 ;
8267 char * kwnames[] = {
8268 (char *) "self",(char *) "row",(char *) "col", NULL
8269 };
8270
8271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8273 if (!SWIG_IsOK(res1)) {
8274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8275 }
8276 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8277 ecode2 = SWIG_AsVal_int(obj1, &val2);
8278 if (!SWIG_IsOK(ecode2)) {
8279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8280 }
8281 arg2 = static_cast< int >(val2);
8282 ecode3 = SWIG_AsVal_int(obj2, &val3);
8283 if (!SWIG_IsOK(ecode3)) {
8284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8285 }
8286 arg3 = static_cast< int >(val3);
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 result = (long)(arg1)->GetValueAsLong(arg2,arg3);
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_From_long(static_cast< long >(result));
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj = 0;
8302 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8303 int arg2 ;
8304 int arg3 ;
8305 double result;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 int val2 ;
8309 int ecode2 = 0 ;
8310 int val3 ;
8311 int ecode3 = 0 ;
8312 PyObject * obj0 = 0 ;
8313 PyObject * obj1 = 0 ;
8314 PyObject * obj2 = 0 ;
8315 char * kwnames[] = {
8316 (char *) "self",(char *) "row",(char *) "col", NULL
8317 };
8318
8319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsDouble",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8323 }
8324 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8325 ecode2 = SWIG_AsVal_int(obj1, &val2);
8326 if (!SWIG_IsOK(ecode2)) {
8327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8328 }
8329 arg2 = static_cast< int >(val2);
8330 ecode3 = SWIG_AsVal_int(obj2, &val3);
8331 if (!SWIG_IsOK(ecode3)) {
8332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8333 }
8334 arg3 = static_cast< int >(val3);
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 result = (double)(arg1)->GetValueAsDouble(arg2,arg3);
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 resultobj = SWIG_From_double(static_cast< double >(result));
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 SWIGINTERN PyObject *_wrap_GridTableBase_GetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj = 0;
8350 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8351 int arg2 ;
8352 int arg3 ;
8353 bool result;
8354 void *argp1 = 0 ;
8355 int res1 = 0 ;
8356 int val2 ;
8357 int ecode2 = 0 ;
8358 int val3 ;
8359 int ecode3 = 0 ;
8360 PyObject * obj0 = 0 ;
8361 PyObject * obj1 = 0 ;
8362 PyObject * obj2 = 0 ;
8363 char * kwnames[] = {
8364 (char *) "self",(char *) "row",(char *) "col", NULL
8365 };
8366
8367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_GetValueAsBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8369 if (!SWIG_IsOK(res1)) {
8370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8371 }
8372 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8373 ecode2 = SWIG_AsVal_int(obj1, &val2);
8374 if (!SWIG_IsOK(ecode2)) {
8375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8376 }
8377 arg2 = static_cast< int >(val2);
8378 ecode3 = SWIG_AsVal_int(obj2, &val3);
8379 if (!SWIG_IsOK(ecode3)) {
8380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8381 }
8382 arg3 = static_cast< int >(val3);
8383 {
8384 PyThreadState* __tstate = wxPyBeginAllowThreads();
8385 result = (bool)(arg1)->GetValueAsBool(arg2,arg3);
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 {
8390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8391 }
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8401 int arg2 ;
8402 int arg3 ;
8403 long arg4 ;
8404 void *argp1 = 0 ;
8405 int res1 = 0 ;
8406 int val2 ;
8407 int ecode2 = 0 ;
8408 int val3 ;
8409 int ecode3 = 0 ;
8410 long val4 ;
8411 int ecode4 = 0 ;
8412 PyObject * obj0 = 0 ;
8413 PyObject * obj1 = 0 ;
8414 PyObject * obj2 = 0 ;
8415 PyObject * obj3 = 0 ;
8416 char * kwnames[] = {
8417 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8418 };
8419
8420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsLong",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8422 if (!SWIG_IsOK(res1)) {
8423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8424 }
8425 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8426 ecode2 = SWIG_AsVal_int(obj1, &val2);
8427 if (!SWIG_IsOK(ecode2)) {
8428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "2"" of type '" "int""'");
8429 }
8430 arg2 = static_cast< int >(val2);
8431 ecode3 = SWIG_AsVal_int(obj2, &val3);
8432 if (!SWIG_IsOK(ecode3)) {
8433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "3"" of type '" "int""'");
8434 }
8435 arg3 = static_cast< int >(val3);
8436 ecode4 = SWIG_AsVal_long(obj3, &val4);
8437 if (!SWIG_IsOK(ecode4)) {
8438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsLong" "', expected argument " "4"" of type '" "long""'");
8439 }
8440 arg4 = static_cast< long >(val4);
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 (arg1)->SetValueAsLong(arg2,arg3,arg4);
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 resultobj = SWIG_Py_Void();
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj = 0;
8456 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8457 int arg2 ;
8458 int arg3 ;
8459 double arg4 ;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 int val2 ;
8463 int ecode2 = 0 ;
8464 int val3 ;
8465 int ecode3 = 0 ;
8466 double val4 ;
8467 int ecode4 = 0 ;
8468 PyObject * obj0 = 0 ;
8469 PyObject * obj1 = 0 ;
8470 PyObject * obj2 = 0 ;
8471 PyObject * obj3 = 0 ;
8472 char * kwnames[] = {
8473 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8474 };
8475
8476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsDouble",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8478 if (!SWIG_IsOK(res1)) {
8479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8480 }
8481 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8482 ecode2 = SWIG_AsVal_int(obj1, &val2);
8483 if (!SWIG_IsOK(ecode2)) {
8484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "2"" of type '" "int""'");
8485 }
8486 arg2 = static_cast< int >(val2);
8487 ecode3 = SWIG_AsVal_int(obj2, &val3);
8488 if (!SWIG_IsOK(ecode3)) {
8489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "3"" of type '" "int""'");
8490 }
8491 arg3 = static_cast< int >(val3);
8492 ecode4 = SWIG_AsVal_double(obj3, &val4);
8493 if (!SWIG_IsOK(ecode4)) {
8494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsDouble" "', expected argument " "4"" of type '" "double""'");
8495 }
8496 arg4 = static_cast< double >(val4);
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 (arg1)->SetValueAsDouble(arg2,arg3,arg4);
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_Py_Void();
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_GridTableBase_SetValueAsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8511 PyObject *resultobj = 0;
8512 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8513 int arg2 ;
8514 int arg3 ;
8515 bool arg4 ;
8516 void *argp1 = 0 ;
8517 int res1 = 0 ;
8518 int val2 ;
8519 int ecode2 = 0 ;
8520 int val3 ;
8521 int ecode3 = 0 ;
8522 bool val4 ;
8523 int ecode4 = 0 ;
8524 PyObject * obj0 = 0 ;
8525 PyObject * obj1 = 0 ;
8526 PyObject * obj2 = 0 ;
8527 PyObject * obj3 = 0 ;
8528 char * kwnames[] = {
8529 (char *) "self",(char *) "row",(char *) "col",(char *) "value", NULL
8530 };
8531
8532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetValueAsBool",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8534 if (!SWIG_IsOK(res1)) {
8535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8536 }
8537 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8538 ecode2 = SWIG_AsVal_int(obj1, &val2);
8539 if (!SWIG_IsOK(ecode2)) {
8540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "2"" of type '" "int""'");
8541 }
8542 arg2 = static_cast< int >(val2);
8543 ecode3 = SWIG_AsVal_int(obj2, &val3);
8544 if (!SWIG_IsOK(ecode3)) {
8545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "3"" of type '" "int""'");
8546 }
8547 arg3 = static_cast< int >(val3);
8548 ecode4 = SWIG_AsVal_bool(obj3, &val4);
8549 if (!SWIG_IsOK(ecode4)) {
8550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetValueAsBool" "', expected argument " "4"" of type '" "bool""'");
8551 }
8552 arg4 = static_cast< bool >(val4);
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 (arg1)->SetValueAsBool(arg2,arg3,arg4);
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 resultobj = SWIG_Py_Void();
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 SWIGINTERN PyObject *_wrap_GridTableBase_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8567 PyObject *resultobj = 0;
8568 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8569 void *argp1 = 0 ;
8570 int res1 = 0 ;
8571 PyObject *swig_obj[1] ;
8572
8573 if (!args) SWIG_fail;
8574 swig_obj[0] = args;
8575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8576 if (!SWIG_IsOK(res1)) {
8577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_Clear" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8578 }
8579 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 (arg1)->Clear();
8583 wxPyEndAllowThreads(__tstate);
8584 if (PyErr_Occurred()) SWIG_fail;
8585 }
8586 resultobj = SWIG_Py_Void();
8587 return resultobj;
8588 fail:
8589 return NULL;
8590 }
8591
8592
8593 SWIGINTERN PyObject *_wrap_GridTableBase_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj = 0;
8595 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8596 size_t arg2 = (size_t) 0 ;
8597 size_t arg3 = (size_t) 1 ;
8598 bool result;
8599 void *argp1 = 0 ;
8600 int res1 = 0 ;
8601 size_t val2 ;
8602 int ecode2 = 0 ;
8603 size_t val3 ;
8604 int ecode3 = 0 ;
8605 PyObject * obj0 = 0 ;
8606 PyObject * obj1 = 0 ;
8607 PyObject * obj2 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8616 }
8617 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8618 if (obj1) {
8619 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8620 if (!SWIG_IsOK(ecode2)) {
8621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertRows" "', expected argument " "2"" of type '" "size_t""'");
8622 }
8623 arg2 = static_cast< size_t >(val2);
8624 }
8625 if (obj2) {
8626 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8627 if (!SWIG_IsOK(ecode3)) {
8628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertRows" "', expected argument " "3"" of type '" "size_t""'");
8629 }
8630 arg3 = static_cast< size_t >(val3);
8631 }
8632 {
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 result = (bool)(arg1)->InsertRows(arg2,arg3);
8635 wxPyEndAllowThreads(__tstate);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 {
8639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8640 }
8641 return resultobj;
8642 fail:
8643 return NULL;
8644 }
8645
8646
8647 SWIGINTERN PyObject *_wrap_GridTableBase_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8648 PyObject *resultobj = 0;
8649 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8650 size_t arg2 = (size_t) 1 ;
8651 bool result;
8652 void *argp1 = 0 ;
8653 int res1 = 0 ;
8654 size_t val2 ;
8655 int ecode2 = 0 ;
8656 PyObject * obj0 = 0 ;
8657 PyObject * obj1 = 0 ;
8658 char * kwnames[] = {
8659 (char *) "self",(char *) "numRows", NULL
8660 };
8661
8662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendRows",kwnames,&obj0,&obj1)) SWIG_fail;
8663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8666 }
8667 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8668 if (obj1) {
8669 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8670 if (!SWIG_IsOK(ecode2)) {
8671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendRows" "', expected argument " "2"" of type '" "size_t""'");
8672 }
8673 arg2 = static_cast< size_t >(val2);
8674 }
8675 {
8676 PyThreadState* __tstate = wxPyBeginAllowThreads();
8677 result = (bool)(arg1)->AppendRows(arg2);
8678 wxPyEndAllowThreads(__tstate);
8679 if (PyErr_Occurred()) SWIG_fail;
8680 }
8681 {
8682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8683 }
8684 return resultobj;
8685 fail:
8686 return NULL;
8687 }
8688
8689
8690 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8691 PyObject *resultobj = 0;
8692 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8693 size_t arg2 = (size_t) 0 ;
8694 size_t arg3 = (size_t) 1 ;
8695 bool result;
8696 void *argp1 = 0 ;
8697 int res1 = 0 ;
8698 size_t val2 ;
8699 int ecode2 = 0 ;
8700 size_t val3 ;
8701 int ecode3 = 0 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 PyObject * obj2 = 0 ;
8705 char * kwnames[] = {
8706 (char *) "self",(char *) "pos",(char *) "numRows", NULL
8707 };
8708
8709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8711 if (!SWIG_IsOK(res1)) {
8712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteRows" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8713 }
8714 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8715 if (obj1) {
8716 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8717 if (!SWIG_IsOK(ecode2)) {
8718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteRows" "', expected argument " "2"" of type '" "size_t""'");
8719 }
8720 arg2 = static_cast< size_t >(val2);
8721 }
8722 if (obj2) {
8723 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8724 if (!SWIG_IsOK(ecode3)) {
8725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteRows" "', expected argument " "3"" of type '" "size_t""'");
8726 }
8727 arg3 = static_cast< size_t >(val3);
8728 }
8729 {
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 result = (bool)(arg1)->DeleteRows(arg2,arg3);
8732 wxPyEndAllowThreads(__tstate);
8733 if (PyErr_Occurred()) SWIG_fail;
8734 }
8735 {
8736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8737 }
8738 return resultobj;
8739 fail:
8740 return NULL;
8741 }
8742
8743
8744 SWIGINTERN PyObject *_wrap_GridTableBase_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj = 0;
8746 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8747 size_t arg2 = (size_t) 0 ;
8748 size_t arg3 = (size_t) 1 ;
8749 bool result;
8750 void *argp1 = 0 ;
8751 int res1 = 0 ;
8752 size_t val2 ;
8753 int ecode2 = 0 ;
8754 size_t val3 ;
8755 int ecode3 = 0 ;
8756 PyObject * obj0 = 0 ;
8757 PyObject * obj1 = 0 ;
8758 PyObject * obj2 = 0 ;
8759 char * kwnames[] = {
8760 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8761 };
8762
8763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_InsertCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8765 if (!SWIG_IsOK(res1)) {
8766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_InsertCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8767 }
8768 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8769 if (obj1) {
8770 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8771 if (!SWIG_IsOK(ecode2)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_InsertCols" "', expected argument " "2"" of type '" "size_t""'");
8773 }
8774 arg2 = static_cast< size_t >(val2);
8775 }
8776 if (obj2) {
8777 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8778 if (!SWIG_IsOK(ecode3)) {
8779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_InsertCols" "', expected argument " "3"" of type '" "size_t""'");
8780 }
8781 arg3 = static_cast< size_t >(val3);
8782 }
8783 {
8784 PyThreadState* __tstate = wxPyBeginAllowThreads();
8785 result = (bool)(arg1)->InsertCols(arg2,arg3);
8786 wxPyEndAllowThreads(__tstate);
8787 if (PyErr_Occurred()) SWIG_fail;
8788 }
8789 {
8790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8791 }
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_GridTableBase_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj = 0;
8800 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8801 size_t arg2 = (size_t) 1 ;
8802 bool result;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 size_t val2 ;
8806 int ecode2 = 0 ;
8807 PyObject * obj0 = 0 ;
8808 PyObject * obj1 = 0 ;
8809 char * kwnames[] = {
8810 (char *) "self",(char *) "numCols", NULL
8811 };
8812
8813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GridTableBase_AppendCols",kwnames,&obj0,&obj1)) SWIG_fail;
8814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8815 if (!SWIG_IsOK(res1)) {
8816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_AppendCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8817 }
8818 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8819 if (obj1) {
8820 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8821 if (!SWIG_IsOK(ecode2)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_AppendCols" "', expected argument " "2"" of type '" "size_t""'");
8823 }
8824 arg2 = static_cast< size_t >(val2);
8825 }
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 result = (bool)(arg1)->AppendCols(arg2);
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 {
8833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8834 }
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 SWIGINTERN PyObject *_wrap_GridTableBase_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8842 PyObject *resultobj = 0;
8843 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8844 size_t arg2 = (size_t) 0 ;
8845 size_t arg3 = (size_t) 1 ;
8846 bool result;
8847 void *argp1 = 0 ;
8848 int res1 = 0 ;
8849 size_t val2 ;
8850 int ecode2 = 0 ;
8851 size_t val3 ;
8852 int ecode3 = 0 ;
8853 PyObject * obj0 = 0 ;
8854 PyObject * obj1 = 0 ;
8855 PyObject * obj2 = 0 ;
8856 char * kwnames[] = {
8857 (char *) "self",(char *) "pos",(char *) "numCols", NULL
8858 };
8859
8860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GridTableBase_DeleteCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8862 if (!SWIG_IsOK(res1)) {
8863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_DeleteCols" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8864 }
8865 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8866 if (obj1) {
8867 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8868 if (!SWIG_IsOK(ecode2)) {
8869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_DeleteCols" "', expected argument " "2"" of type '" "size_t""'");
8870 }
8871 arg2 = static_cast< size_t >(val2);
8872 }
8873 if (obj2) {
8874 ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8875 if (!SWIG_IsOK(ecode3)) {
8876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_DeleteCols" "', expected argument " "3"" of type '" "size_t""'");
8877 }
8878 arg3 = static_cast< size_t >(val3);
8879 }
8880 {
8881 PyThreadState* __tstate = wxPyBeginAllowThreads();
8882 result = (bool)(arg1)->DeleteCols(arg2,arg3);
8883 wxPyEndAllowThreads(__tstate);
8884 if (PyErr_Occurred()) SWIG_fail;
8885 }
8886 {
8887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8888 }
8889 return resultobj;
8890 fail:
8891 return NULL;
8892 }
8893
8894
8895 SWIGINTERN PyObject *_wrap_GridTableBase_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8896 PyObject *resultobj = 0;
8897 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8898 int arg2 ;
8899 wxString result;
8900 void *argp1 = 0 ;
8901 int res1 = 0 ;
8902 int val2 ;
8903 int ecode2 = 0 ;
8904 PyObject * obj0 = 0 ;
8905 PyObject * obj1 = 0 ;
8906 char * kwnames[] = {
8907 (char *) "self",(char *) "row", NULL
8908 };
8909
8910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8912 if (!SWIG_IsOK(res1)) {
8913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8914 }
8915 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8916 ecode2 = SWIG_AsVal_int(obj1, &val2);
8917 if (!SWIG_IsOK(ecode2)) {
8918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
8919 }
8920 arg2 = static_cast< int >(val2);
8921 {
8922 PyThreadState* __tstate = wxPyBeginAllowThreads();
8923 result = (arg1)->GetRowLabelValue(arg2);
8924 wxPyEndAllowThreads(__tstate);
8925 if (PyErr_Occurred()) SWIG_fail;
8926 }
8927 {
8928 #if wxUSE_UNICODE
8929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8930 #else
8931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8932 #endif
8933 }
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 SWIGINTERN PyObject *_wrap_GridTableBase_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8941 PyObject *resultobj = 0;
8942 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8943 int arg2 ;
8944 wxString result;
8945 void *argp1 = 0 ;
8946 int res1 = 0 ;
8947 int val2 ;
8948 int ecode2 = 0 ;
8949 PyObject * obj0 = 0 ;
8950 PyObject * obj1 = 0 ;
8951 char * kwnames[] = {
8952 (char *) "self",(char *) "col", NULL
8953 };
8954
8955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableBase_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
8956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
8957 if (!SWIG_IsOK(res1)) {
8958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
8959 }
8960 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
8961 ecode2 = SWIG_AsVal_int(obj1, &val2);
8962 if (!SWIG_IsOK(ecode2)) {
8963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
8964 }
8965 arg2 = static_cast< int >(val2);
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 result = (arg1)->GetColLabelValue(arg2);
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 {
8973 #if wxUSE_UNICODE
8974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8975 #else
8976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8977 #endif
8978 }
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj = 0;
8987 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
8988 int arg2 ;
8989 wxString *arg3 = 0 ;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 int val2 ;
8993 int ecode2 = 0 ;
8994 bool temp3 = false ;
8995 PyObject * obj0 = 0 ;
8996 PyObject * obj1 = 0 ;
8997 PyObject * obj2 = 0 ;
8998 char * kwnames[] = {
8999 (char *) "self",(char *) "row",(char *) "value", NULL
9000 };
9001
9002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9004 if (!SWIG_IsOK(res1)) {
9005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9006 }
9007 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9008 ecode2 = SWIG_AsVal_int(obj1, &val2);
9009 if (!SWIG_IsOK(ecode2)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
9011 }
9012 arg2 = static_cast< int >(val2);
9013 {
9014 arg3 = wxString_in_helper(obj2);
9015 if (arg3 == NULL) SWIG_fail;
9016 temp3 = true;
9017 }
9018 {
9019 PyThreadState* __tstate = wxPyBeginAllowThreads();
9020 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 resultobj = SWIG_Py_Void();
9025 {
9026 if (temp3)
9027 delete arg3;
9028 }
9029 return resultobj;
9030 fail:
9031 {
9032 if (temp3)
9033 delete arg3;
9034 }
9035 return NULL;
9036 }
9037
9038
9039 SWIGINTERN PyObject *_wrap_GridTableBase_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9040 PyObject *resultobj = 0;
9041 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9042 int arg2 ;
9043 wxString *arg3 = 0 ;
9044 void *argp1 = 0 ;
9045 int res1 = 0 ;
9046 int val2 ;
9047 int ecode2 = 0 ;
9048 bool temp3 = false ;
9049 PyObject * obj0 = 0 ;
9050 PyObject * obj1 = 0 ;
9051 PyObject * obj2 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "self",(char *) "col",(char *) "value", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9060 }
9061 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9062 ecode2 = SWIG_AsVal_int(obj1, &val2);
9063 if (!SWIG_IsOK(ecode2)) {
9064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
9065 }
9066 arg2 = static_cast< int >(val2);
9067 {
9068 arg3 = wxString_in_helper(obj2);
9069 if (arg3 == NULL) SWIG_fail;
9070 temp3 = true;
9071 }
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
9075 wxPyEndAllowThreads(__tstate);
9076 if (PyErr_Occurred()) SWIG_fail;
9077 }
9078 resultobj = SWIG_Py_Void();
9079 {
9080 if (temp3)
9081 delete arg3;
9082 }
9083 return resultobj;
9084 fail:
9085 {
9086 if (temp3)
9087 delete arg3;
9088 }
9089 return NULL;
9090 }
9091
9092
9093 SWIGINTERN PyObject *_wrap_GridTableBase_CanHaveAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9094 PyObject *resultobj = 0;
9095 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9096 bool result;
9097 void *argp1 = 0 ;
9098 int res1 = 0 ;
9099 PyObject *swig_obj[1] ;
9100
9101 if (!args) SWIG_fail;
9102 swig_obj[0] = args;
9103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9104 if (!SWIG_IsOK(res1)) {
9105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_CanHaveAttributes" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9106 }
9107 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9108 {
9109 PyThreadState* __tstate = wxPyBeginAllowThreads();
9110 result = (bool)(arg1)->CanHaveAttributes();
9111 wxPyEndAllowThreads(__tstate);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 {
9115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9116 }
9117 return resultobj;
9118 fail:
9119 return NULL;
9120 }
9121
9122
9123 SWIGINTERN PyObject *_wrap_GridTableBase_GetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9124 PyObject *resultobj = 0;
9125 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9126 int arg2 ;
9127 int arg3 ;
9128 wxGridCellAttr::wxAttrKind arg4 ;
9129 wxGridCellAttr *result = 0 ;
9130 void *argp1 = 0 ;
9131 int res1 = 0 ;
9132 int val2 ;
9133 int ecode2 = 0 ;
9134 int val3 ;
9135 int ecode3 = 0 ;
9136 int val4 ;
9137 int ecode4 = 0 ;
9138 PyObject * obj0 = 0 ;
9139 PyObject * obj1 = 0 ;
9140 PyObject * obj2 = 0 ;
9141 PyObject * obj3 = 0 ;
9142 char * kwnames[] = {
9143 (char *) "self",(char *) "row",(char *) "col",(char *) "kind", NULL
9144 };
9145
9146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_GetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_GetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9150 }
9151 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9152 ecode2 = SWIG_AsVal_int(obj1, &val2);
9153 if (!SWIG_IsOK(ecode2)) {
9154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableBase_GetAttr" "', expected argument " "2"" of type '" "int""'");
9155 }
9156 arg2 = static_cast< int >(val2);
9157 ecode3 = SWIG_AsVal_int(obj2, &val3);
9158 if (!SWIG_IsOK(ecode3)) {
9159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_GetAttr" "', expected argument " "3"" of type '" "int""'");
9160 }
9161 arg3 = static_cast< int >(val3);
9162 ecode4 = SWIG_AsVal_int(obj3, &val4);
9163 if (!SWIG_IsOK(ecode4)) {
9164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_GetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr::wxAttrKind""'");
9165 }
9166 arg4 = static_cast< wxGridCellAttr::wxAttrKind >(val4);
9167 {
9168 PyThreadState* __tstate = wxPyBeginAllowThreads();
9169 result = (wxGridCellAttr *)(arg1)->GetAttr(arg2,arg3,arg4);
9170 wxPyEndAllowThreads(__tstate);
9171 if (PyErr_Occurred()) SWIG_fail;
9172 }
9173 {
9174 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
9175 }
9176 return resultobj;
9177 fail:
9178 return NULL;
9179 }
9180
9181
9182 SWIGINTERN PyObject *_wrap_GridTableBase_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9183 PyObject *resultobj = 0;
9184 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9185 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9186 int arg3 ;
9187 int arg4 ;
9188 void *argp1 = 0 ;
9189 int res1 = 0 ;
9190 void *argp2 = 0 ;
9191 int res2 = 0 ;
9192 int val3 ;
9193 int ecode3 = 0 ;
9194 int val4 ;
9195 int ecode4 = 0 ;
9196 PyObject * obj0 = 0 ;
9197 PyObject * obj1 = 0 ;
9198 PyObject * obj2 = 0 ;
9199 PyObject * obj3 = 0 ;
9200 char * kwnames[] = {
9201 (char *) "self",(char *) "attr",(char *) "row",(char *) "col", NULL
9202 };
9203
9204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:GridTableBase_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9206 if (!SWIG_IsOK(res1)) {
9207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9208 }
9209 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9211 if (!SWIG_IsOK(res2)) {
9212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9213 }
9214 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9215 ecode3 = SWIG_AsVal_int(obj2, &val3);
9216 if (!SWIG_IsOK(ecode3)) {
9217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetAttr" "', expected argument " "3"" of type '" "int""'");
9218 }
9219 arg3 = static_cast< int >(val3);
9220 ecode4 = SWIG_AsVal_int(obj3, &val4);
9221 if (!SWIG_IsOK(ecode4)) {
9222 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridTableBase_SetAttr" "', expected argument " "4"" of type '" "int""'");
9223 }
9224 arg4 = static_cast< int >(val4);
9225 {
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 (arg1)->SetAttr(arg2,arg3,arg4);
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_Py_Void();
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 SWIGINTERN PyObject *_wrap_GridTableBase_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9239 PyObject *resultobj = 0;
9240 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9241 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9242 int arg3 ;
9243 void *argp1 = 0 ;
9244 int res1 = 0 ;
9245 void *argp2 = 0 ;
9246 int res2 = 0 ;
9247 int val3 ;
9248 int ecode3 = 0 ;
9249 PyObject * obj0 = 0 ;
9250 PyObject * obj1 = 0 ;
9251 PyObject * obj2 = 0 ;
9252 char * kwnames[] = {
9253 (char *) "self",(char *) "attr",(char *) "row", NULL
9254 };
9255
9256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9258 if (!SWIG_IsOK(res1)) {
9259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9260 }
9261 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9263 if (!SWIG_IsOK(res2)) {
9264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9265 }
9266 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9267 ecode3 = SWIG_AsVal_int(obj2, &val3);
9268 if (!SWIG_IsOK(ecode3)) {
9269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetRowAttr" "', expected argument " "3"" of type '" "int""'");
9270 }
9271 arg3 = static_cast< int >(val3);
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 (arg1)->SetRowAttr(arg2,arg3);
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 resultobj = SWIG_Py_Void();
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 SWIGINTERN PyObject *_wrap_GridTableBase_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj = 0;
9287 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9288 wxGridCellAttr *arg2 = (wxGridCellAttr *) 0 ;
9289 int arg3 ;
9290 void *argp1 = 0 ;
9291 int res1 = 0 ;
9292 void *argp2 = 0 ;
9293 int res2 = 0 ;
9294 int val3 ;
9295 int ecode3 = 0 ;
9296 PyObject * obj0 = 0 ;
9297 PyObject * obj1 = 0 ;
9298 PyObject * obj2 = 0 ;
9299 char * kwnames[] = {
9300 (char *) "self",(char *) "attr",(char *) "col", NULL
9301 };
9302
9303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridTableBase_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9305 if (!SWIG_IsOK(res1)) {
9306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableBase_SetColAttr" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9307 }
9308 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
9310 if (!SWIG_IsOK(res2)) {
9311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableBase_SetColAttr" "', expected argument " "2"" of type '" "wxGridCellAttr *""'");
9312 }
9313 arg2 = reinterpret_cast< wxGridCellAttr * >(argp2);
9314 ecode3 = SWIG_AsVal_int(obj2, &val3);
9315 if (!SWIG_IsOK(ecode3)) {
9316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridTableBase_SetColAttr" "', expected argument " "3"" of type '" "int""'");
9317 }
9318 arg3 = static_cast< int >(val3);
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 (arg1)->SetColAttr(arg2,arg3);
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *GridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333 PyObject *obj;
9334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9335 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableBase, SWIG_NewClientData(obj));
9336 return SWIG_Py_Void();
9337 }
9338
9339 SWIGINTERN PyObject *_wrap_new_PyGridTableBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxPyGridTableBase *result = 0 ;
9342
9343 if (!SWIG_Python_UnpackTuple(args,"new_PyGridTableBase",0,0,0)) SWIG_fail;
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (wxPyGridTableBase *)new wxPyGridTableBase();
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyGridTableBase, SWIG_POINTER_NEW | 0 );
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_PyGridTableBase__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9358 PyObject *resultobj = 0;
9359 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9360 PyObject *arg2 = (PyObject *) 0 ;
9361 PyObject *arg3 = (PyObject *) 0 ;
9362 void *argp1 = 0 ;
9363 int res1 = 0 ;
9364 PyObject * obj0 = 0 ;
9365 PyObject * obj1 = 0 ;
9366 PyObject * obj2 = 0 ;
9367 char * kwnames[] = {
9368 (char *) "self",(char *) "self",(char *) "_class", NULL
9369 };
9370
9371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyGridTableBase__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9373 if (!SWIG_IsOK(res1)) {
9374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9375 }
9376 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9377 arg2 = obj1;
9378 arg3 = obj2;
9379 {
9380 PyThreadState* __tstate = wxPyBeginAllowThreads();
9381 (arg1)->_setCallbackInfo(arg2,arg3);
9382 wxPyEndAllowThreads(__tstate);
9383 if (PyErr_Occurred()) SWIG_fail;
9384 }
9385 resultobj = SWIG_Py_Void();
9386 return resultobj;
9387 fail:
9388 return NULL;
9389 }
9390
9391
9392 SWIGINTERN PyObject *_wrap_PyGridTableBase_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9393 PyObject *resultobj = 0;
9394 wxPyGridTableBase *arg1 = (wxPyGridTableBase *) 0 ;
9395 void *argp1 = 0 ;
9396 int res1 = 0 ;
9397 PyObject *swig_obj[1] ;
9398
9399 if (!args) SWIG_fail;
9400 swig_obj[0] = args;
9401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyGridTableBase, 0 | 0 );
9402 if (!SWIG_IsOK(res1)) {
9403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyGridTableBase_Destroy" "', expected argument " "1"" of type '" "wxPyGridTableBase *""'");
9404 }
9405 arg1 = reinterpret_cast< wxPyGridTableBase * >(argp1);
9406 {
9407 PyThreadState* __tstate = wxPyBeginAllowThreads();
9408 wxPyGridTableBase_Destroy(arg1);
9409 wxPyEndAllowThreads(__tstate);
9410 if (PyErr_Occurred()) SWIG_fail;
9411 }
9412 resultobj = SWIG_Py_Void();
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *PyGridTableBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9420 PyObject *obj;
9421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9422 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyGridTableBase, SWIG_NewClientData(obj));
9423 return SWIG_Py_Void();
9424 }
9425
9426 SWIGINTERN PyObject *PyGridTableBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9427 return SWIG_Python_InitShadowInstance(args);
9428 }
9429
9430 SWIGINTERN PyObject *_wrap_new_GridStringTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj = 0;
9432 int arg1 = (int) 0 ;
9433 int arg2 = (int) 0 ;
9434 wxGridStringTable *result = 0 ;
9435 int val1 ;
9436 int ecode1 = 0 ;
9437 int val2 ;
9438 int ecode2 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 char * kwnames[] = {
9442 (char *) "numRows",(char *) "numCols", NULL
9443 };
9444
9445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridStringTable",kwnames,&obj0,&obj1)) SWIG_fail;
9446 if (obj0) {
9447 ecode1 = SWIG_AsVal_int(obj0, &val1);
9448 if (!SWIG_IsOK(ecode1)) {
9449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridStringTable" "', expected argument " "1"" of type '" "int""'");
9450 }
9451 arg1 = static_cast< int >(val1);
9452 }
9453 if (obj1) {
9454 ecode2 = SWIG_AsVal_int(obj1, &val2);
9455 if (!SWIG_IsOK(ecode2)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridStringTable" "', expected argument " "2"" of type '" "int""'");
9457 }
9458 arg2 = static_cast< int >(val2);
9459 }
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = (wxGridStringTable *)new wxGridStringTable(arg1,arg2);
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridStringTable, SWIG_POINTER_NEW | 0 );
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *GridStringTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474 PyObject *obj;
9475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9476 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridStringTable, SWIG_NewClientData(obj));
9477 return SWIG_Py_Void();
9478 }
9479
9480 SWIGINTERN PyObject *GridStringTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 return SWIG_Python_InitShadowInstance(args);
9482 }
9483
9484 SWIGINTERN PyObject *_wrap_new_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj = 0;
9486 wxGridTableBase *arg1 = (wxGridTableBase *) 0 ;
9487 int arg2 ;
9488 int arg3 = (int) -1 ;
9489 int arg4 = (int) -1 ;
9490 wxGridTableMessage *result = 0 ;
9491 void *argp1 = 0 ;
9492 int res1 = 0 ;
9493 int val2 ;
9494 int ecode2 = 0 ;
9495 int val3 ;
9496 int ecode3 = 0 ;
9497 int val4 ;
9498 int ecode4 = 0 ;
9499 PyObject * obj0 = 0 ;
9500 PyObject * obj1 = 0 ;
9501 PyObject * obj2 = 0 ;
9502 PyObject * obj3 = 0 ;
9503 char * kwnames[] = {
9504 (char *) "table",(char *) "id",(char *) "comInt1",(char *) "comInt2", NULL
9505 };
9506
9507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_GridTableMessage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9509 if (!SWIG_IsOK(res1)) {
9510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableBase *""'");
9511 }
9512 arg1 = reinterpret_cast< wxGridTableBase * >(argp1);
9513 ecode2 = SWIG_AsVal_int(obj1, &val2);
9514 if (!SWIG_IsOK(ecode2)) {
9515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridTableMessage" "', expected argument " "2"" of type '" "int""'");
9516 }
9517 arg2 = static_cast< int >(val2);
9518 if (obj2) {
9519 ecode3 = SWIG_AsVal_int(obj2, &val3);
9520 if (!SWIG_IsOK(ecode3)) {
9521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridTableMessage" "', expected argument " "3"" of type '" "int""'");
9522 }
9523 arg3 = static_cast< int >(val3);
9524 }
9525 if (obj3) {
9526 ecode4 = SWIG_AsVal_int(obj3, &val4);
9527 if (!SWIG_IsOK(ecode4)) {
9528 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridTableMessage" "', expected argument " "4"" of type '" "int""'");
9529 }
9530 arg4 = static_cast< int >(val4);
9531 }
9532 {
9533 PyThreadState* __tstate = wxPyBeginAllowThreads();
9534 result = (wxGridTableMessage *)new wxGridTableMessage(arg1,arg2,arg3,arg4);
9535 wxPyEndAllowThreads(__tstate);
9536 if (PyErr_Occurred()) SWIG_fail;
9537 }
9538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_NEW | 0 );
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_delete_GridTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9546 PyObject *resultobj = 0;
9547 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9548 void *argp1 = 0 ;
9549 int res1 = 0 ;
9550 PyObject *swig_obj[1] ;
9551
9552 if (!args) SWIG_fail;
9553 swig_obj[0] = args;
9554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, SWIG_POINTER_DISOWN | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridTableMessage" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9557 }
9558 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 delete arg1;
9562
9563 wxPyEndAllowThreads(__tstate);
9564 if (PyErr_Occurred()) SWIG_fail;
9565 }
9566 resultobj = SWIG_Py_Void();
9567 return resultobj;
9568 fail:
9569 return NULL;
9570 }
9571
9572
9573 SWIGINTERN PyObject *_wrap_GridTableMessage_SetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9574 PyObject *resultobj = 0;
9575 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9576 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
9577 void *argp1 = 0 ;
9578 int res1 = 0 ;
9579 void *argp2 = 0 ;
9580 int res2 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 char * kwnames[] = {
9584 (char *) "self",(char *) "table", NULL
9585 };
9586
9587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetTableObject",kwnames,&obj0,&obj1)) SWIG_fail;
9588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9589 if (!SWIG_IsOK(res1)) {
9590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9591 }
9592 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridTableBase, 0 | 0 );
9594 if (!SWIG_IsOK(res2)) {
9595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridTableMessage_SetTableObject" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
9596 }
9597 arg2 = reinterpret_cast< wxGridTableBase * >(argp2);
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 (arg1)->SetTableObject(arg2);
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_Py_Void();
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 SWIGINTERN PyObject *_wrap_GridTableMessage_GetTableObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612 PyObject *resultobj = 0;
9613 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9614 wxGridTableBase *result = 0 ;
9615 void *argp1 = 0 ;
9616 int res1 = 0 ;
9617 PyObject *swig_obj[1] ;
9618
9619 if (!args) SWIG_fail;
9620 swig_obj[0] = args;
9621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9622 if (!SWIG_IsOK(res1)) {
9623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetTableObject" "', expected argument " "1"" of type '" "wxGridTableMessage const *""'");
9624 }
9625 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9626 {
9627 PyThreadState* __tstate = wxPyBeginAllowThreads();
9628 result = (wxGridTableBase *)((wxGridTableMessage const *)arg1)->GetTableObject();
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 {
9633 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
9634 }
9635 return resultobj;
9636 fail:
9637 return NULL;
9638 }
9639
9640
9641 SWIGINTERN PyObject *_wrap_GridTableMessage_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj = 0;
9643 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9644 int arg2 ;
9645 void *argp1 = 0 ;
9646 int res1 = 0 ;
9647 int val2 ;
9648 int ecode2 = 0 ;
9649 PyObject * obj0 = 0 ;
9650 PyObject * obj1 = 0 ;
9651 char * kwnames[] = {
9652 (char *) "self",(char *) "id", NULL
9653 };
9654
9655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
9656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9657 if (!SWIG_IsOK(res1)) {
9658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9659 }
9660 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9661 ecode2 = SWIG_AsVal_int(obj1, &val2);
9662 if (!SWIG_IsOK(ecode2)) {
9663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetId" "', expected argument " "2"" of type '" "int""'");
9664 }
9665 arg2 = static_cast< int >(val2);
9666 {
9667 PyThreadState* __tstate = wxPyBeginAllowThreads();
9668 (arg1)->SetId(arg2);
9669 wxPyEndAllowThreads(__tstate);
9670 if (PyErr_Occurred()) SWIG_fail;
9671 }
9672 resultobj = SWIG_Py_Void();
9673 return resultobj;
9674 fail:
9675 return NULL;
9676 }
9677
9678
9679 SWIGINTERN PyObject *_wrap_GridTableMessage_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9680 PyObject *resultobj = 0;
9681 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9682 int result;
9683 void *argp1 = 0 ;
9684 int res1 = 0 ;
9685 PyObject *swig_obj[1] ;
9686
9687 if (!args) SWIG_fail;
9688 swig_obj[0] = args;
9689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9690 if (!SWIG_IsOK(res1)) {
9691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetId" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9692 }
9693 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9694 {
9695 PyThreadState* __tstate = wxPyBeginAllowThreads();
9696 result = (int)(arg1)->GetId();
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 resultobj = SWIG_From_int(static_cast< int >(result));
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9708 PyObject *resultobj = 0;
9709 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9710 int arg2 ;
9711 void *argp1 = 0 ;
9712 int res1 = 0 ;
9713 int val2 ;
9714 int ecode2 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 char * kwnames[] = {
9718 (char *) "self",(char *) "comInt1", NULL
9719 };
9720
9721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt",kwnames,&obj0,&obj1)) SWIG_fail;
9722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9723 if (!SWIG_IsOK(res1)) {
9724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9725 }
9726 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9727 ecode2 = SWIG_AsVal_int(obj1, &val2);
9728 if (!SWIG_IsOK(ecode2)) {
9729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt" "', expected argument " "2"" of type '" "int""'");
9730 }
9731 arg2 = static_cast< int >(val2);
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 (arg1)->SetCommandInt(arg2);
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_Py_Void();
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *resultobj = 0;
9747 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9748 int result;
9749 void *argp1 = 0 ;
9750 int res1 = 0 ;
9751 PyObject *swig_obj[1] ;
9752
9753 if (!args) SWIG_fail;
9754 swig_obj[0] = args;
9755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9756 if (!SWIG_IsOK(res1)) {
9757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9758 }
9759 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 result = (int)(arg1)->GetCommandInt();
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 resultobj = SWIG_From_int(static_cast< int >(result));
9767 return resultobj;
9768 fail:
9769 return NULL;
9770 }
9771
9772
9773 SWIGINTERN PyObject *_wrap_GridTableMessage_SetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9774 PyObject *resultobj = 0;
9775 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9776 int arg2 ;
9777 void *argp1 = 0 ;
9778 int res1 = 0 ;
9779 int val2 ;
9780 int ecode2 = 0 ;
9781 PyObject * obj0 = 0 ;
9782 PyObject * obj1 = 0 ;
9783 char * kwnames[] = {
9784 (char *) "self",(char *) "comInt2", NULL
9785 };
9786
9787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridTableMessage_SetCommandInt2",kwnames,&obj0,&obj1)) SWIG_fail;
9788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9789 if (!SWIG_IsOK(res1)) {
9790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9791 }
9792 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9793 ecode2 = SWIG_AsVal_int(obj1, &val2);
9794 if (!SWIG_IsOK(ecode2)) {
9795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTableMessage_SetCommandInt2" "', expected argument " "2"" of type '" "int""'");
9796 }
9797 arg2 = static_cast< int >(val2);
9798 {
9799 PyThreadState* __tstate = wxPyBeginAllowThreads();
9800 (arg1)->SetCommandInt2(arg2);
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 resultobj = SWIG_Py_Void();
9805 return resultobj;
9806 fail:
9807 return NULL;
9808 }
9809
9810
9811 SWIGINTERN PyObject *_wrap_GridTableMessage_GetCommandInt2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9812 PyObject *resultobj = 0;
9813 wxGridTableMessage *arg1 = (wxGridTableMessage *) 0 ;
9814 int result;
9815 void *argp1 = 0 ;
9816 int res1 = 0 ;
9817 PyObject *swig_obj[1] ;
9818
9819 if (!args) SWIG_fail;
9820 swig_obj[0] = args;
9821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridTableMessage, 0 | 0 );
9822 if (!SWIG_IsOK(res1)) {
9823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTableMessage_GetCommandInt2" "', expected argument " "1"" of type '" "wxGridTableMessage *""'");
9824 }
9825 arg1 = reinterpret_cast< wxGridTableMessage * >(argp1);
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (int)(arg1)->GetCommandInt2();
9829 wxPyEndAllowThreads(__tstate);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 resultobj = SWIG_From_int(static_cast< int >(result));
9833 return resultobj;
9834 fail:
9835 return NULL;
9836 }
9837
9838
9839 SWIGINTERN PyObject *GridTableMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9840 PyObject *obj;
9841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9842 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridTableMessage, SWIG_NewClientData(obj));
9843 return SWIG_Py_Void();
9844 }
9845
9846 SWIGINTERN PyObject *GridTableMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 return SWIG_Python_InitShadowInstance(args);
9848 }
9849
9850 SWIGINTERN PyObject *_wrap_new_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj = 0;
9852 int arg1 = (int) -1 ;
9853 int arg2 = (int) -1 ;
9854 wxGridCellCoords *result = 0 ;
9855 int val1 ;
9856 int ecode1 = 0 ;
9857 int val2 ;
9858 int ecode2 = 0 ;
9859 PyObject * obj0 = 0 ;
9860 PyObject * obj1 = 0 ;
9861 char * kwnames[] = {
9862 (char *) "r",(char *) "c", NULL
9863 };
9864
9865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridCellCoords",kwnames,&obj0,&obj1)) SWIG_fail;
9866 if (obj0) {
9867 ecode1 = SWIG_AsVal_int(obj0, &val1);
9868 if (!SWIG_IsOK(ecode1)) {
9869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridCellCoords" "', expected argument " "1"" of type '" "int""'");
9870 }
9871 arg1 = static_cast< int >(val1);
9872 }
9873 if (obj1) {
9874 ecode2 = SWIG_AsVal_int(obj1, &val2);
9875 if (!SWIG_IsOK(ecode2)) {
9876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridCellCoords" "', expected argument " "2"" of type '" "int""'");
9877 }
9878 arg2 = static_cast< int >(val2);
9879 }
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 result = (wxGridCellCoords *)new wxGridCellCoords(arg1,arg2);
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_NEW | 0 );
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 SWIGINTERN PyObject *_wrap_delete_GridCellCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 PyObject *resultobj = 0;
9895 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 PyObject *swig_obj[1] ;
9899
9900 if (!args) SWIG_fail;
9901 swig_obj[0] = args;
9902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_DISOWN | 0 );
9903 if (!SWIG_IsOK(res1)) {
9904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridCellCoords" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9905 }
9906 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 delete arg1;
9910
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 resultobj = SWIG_Py_Void();
9915 return resultobj;
9916 fail:
9917 return NULL;
9918 }
9919
9920
9921 SWIGINTERN PyObject *_wrap_GridCellCoords_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9922 PyObject *resultobj = 0;
9923 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9924 int result;
9925 void *argp1 = 0 ;
9926 int res1 = 0 ;
9927 PyObject *swig_obj[1] ;
9928
9929 if (!args) SWIG_fail;
9930 swig_obj[0] = args;
9931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9932 if (!SWIG_IsOK(res1)) {
9933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetRow" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
9934 }
9935 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9936 {
9937 PyThreadState* __tstate = wxPyBeginAllowThreads();
9938 result = (int)((wxGridCellCoords const *)arg1)->GetRow();
9939 wxPyEndAllowThreads(__tstate);
9940 if (PyErr_Occurred()) SWIG_fail;
9941 }
9942 resultobj = SWIG_From_int(static_cast< int >(result));
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 SWIGINTERN PyObject *_wrap_GridCellCoords_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9950 PyObject *resultobj = 0;
9951 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9952 int arg2 ;
9953 void *argp1 = 0 ;
9954 int res1 = 0 ;
9955 int val2 ;
9956 int ecode2 = 0 ;
9957 PyObject * obj0 = 0 ;
9958 PyObject * obj1 = 0 ;
9959 char * kwnames[] = {
9960 (char *) "self",(char *) "n", NULL
9961 };
9962
9963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
9964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9965 if (!SWIG_IsOK(res1)) {
9966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetRow" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
9967 }
9968 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
9969 ecode2 = SWIG_AsVal_int(obj1, &val2);
9970 if (!SWIG_IsOK(ecode2)) {
9971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetRow" "', expected argument " "2"" of type '" "int""'");
9972 }
9973 arg2 = static_cast< int >(val2);
9974 {
9975 PyThreadState* __tstate = wxPyBeginAllowThreads();
9976 (arg1)->SetRow(arg2);
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 resultobj = SWIG_Py_Void();
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 SWIGINTERN PyObject *_wrap_GridCellCoords_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9988 PyObject *resultobj = 0;
9989 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
9990 int result;
9991 void *argp1 = 0 ;
9992 int res1 = 0 ;
9993 PyObject *swig_obj[1] ;
9994
9995 if (!args) SWIG_fail;
9996 swig_obj[0] = args;
9997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
9998 if (!SWIG_IsOK(res1)) {
9999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_GetCol" "', expected argument " "1"" of type '" "wxGridCellCoords const *""'");
10000 }
10001 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = (int)((wxGridCellCoords const *)arg1)->GetCol();
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 resultobj = SWIG_From_int(static_cast< int >(result));
10009 return resultobj;
10010 fail:
10011 return NULL;
10012 }
10013
10014
10015 SWIGINTERN PyObject *_wrap_GridCellCoords_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10016 PyObject *resultobj = 0;
10017 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10018 int arg2 ;
10019 void *argp1 = 0 ;
10020 int res1 = 0 ;
10021 int val2 ;
10022 int ecode2 = 0 ;
10023 PyObject * obj0 = 0 ;
10024 PyObject * obj1 = 0 ;
10025 char * kwnames[] = {
10026 (char *) "self",(char *) "n", NULL
10027 };
10028
10029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
10030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10031 if (!SWIG_IsOK(res1)) {
10032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_SetCol" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10033 }
10034 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10035 ecode2 = SWIG_AsVal_int(obj1, &val2);
10036 if (!SWIG_IsOK(ecode2)) {
10037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_SetCol" "', expected argument " "2"" of type '" "int""'");
10038 }
10039 arg2 = static_cast< int >(val2);
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 (arg1)->SetCol(arg2);
10043 wxPyEndAllowThreads(__tstate);
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 resultobj = SWIG_Py_Void();
10047 return resultobj;
10048 fail:
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_GridCellCoords_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10054 PyObject *resultobj = 0;
10055 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10056 int arg2 ;
10057 int arg3 ;
10058 void *argp1 = 0 ;
10059 int res1 = 0 ;
10060 int val2 ;
10061 int ecode2 = 0 ;
10062 int val3 ;
10063 int ecode3 = 0 ;
10064 PyObject * obj0 = 0 ;
10065 PyObject * obj1 = 0 ;
10066 PyObject * obj2 = 0 ;
10067 char * kwnames[] = {
10068 (char *) "self",(char *) "row",(char *) "col", NULL
10069 };
10070
10071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridCellCoords_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10073 if (!SWIG_IsOK(res1)) {
10074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Set" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10075 }
10076 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10077 ecode2 = SWIG_AsVal_int(obj1, &val2);
10078 if (!SWIG_IsOK(ecode2)) {
10079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridCellCoords_Set" "', expected argument " "2"" of type '" "int""'");
10080 }
10081 arg2 = static_cast< int >(val2);
10082 ecode3 = SWIG_AsVal_int(obj2, &val3);
10083 if (!SWIG_IsOK(ecode3)) {
10084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridCellCoords_Set" "', expected argument " "3"" of type '" "int""'");
10085 }
10086 arg3 = static_cast< int >(val3);
10087 {
10088 PyThreadState* __tstate = wxPyBeginAllowThreads();
10089 (arg1)->Set(arg2,arg3);
10090 wxPyEndAllowThreads(__tstate);
10091 if (PyErr_Occurred()) SWIG_fail;
10092 }
10093 resultobj = SWIG_Py_Void();
10094 return resultobj;
10095 fail:
10096 return NULL;
10097 }
10098
10099
10100 SWIGINTERN PyObject *_wrap_GridCellCoords___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj = 0;
10102 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10103 PyObject *arg2 = (PyObject *) 0 ;
10104 bool result;
10105 void *argp1 = 0 ;
10106 int res1 = 0 ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 char * kwnames[] = {
10110 (char *) "self",(char *) "other", NULL
10111 };
10112
10113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10115 if (!SWIG_IsOK(res1)) {
10116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___eq__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10117 }
10118 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10119 arg2 = obj1;
10120 {
10121 result = (bool)wxGridCellCoords___eq__(arg1,arg2);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 {
10125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10126 }
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *_wrap_GridCellCoords___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj = 0;
10135 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10136 PyObject *arg2 = (PyObject *) 0 ;
10137 bool result;
10138 void *argp1 = 0 ;
10139 int res1 = 0 ;
10140 PyObject * obj0 = 0 ;
10141 PyObject * obj1 = 0 ;
10142 char * kwnames[] = {
10143 (char *) "self",(char *) "other", NULL
10144 };
10145
10146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridCellCoords___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10148 if (!SWIG_IsOK(res1)) {
10149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords___ne__" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10150 }
10151 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10152 arg2 = obj1;
10153 {
10154 result = (bool)wxGridCellCoords___ne__(arg1,arg2);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 {
10158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10159 }
10160 return resultobj;
10161 fail:
10162 return NULL;
10163 }
10164
10165
10166 SWIGINTERN PyObject *_wrap_GridCellCoords_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10167 PyObject *resultobj = 0;
10168 wxGridCellCoords *arg1 = (wxGridCellCoords *) 0 ;
10169 PyObject *result = 0 ;
10170 void *argp1 = 0 ;
10171 int res1 = 0 ;
10172 PyObject *swig_obj[1] ;
10173
10174 if (!args) SWIG_fail;
10175 swig_obj[0] = args;
10176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridCellCoords, 0 | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridCellCoords_Get" "', expected argument " "1"" of type '" "wxGridCellCoords *""'");
10179 }
10180 arg1 = reinterpret_cast< wxGridCellCoords * >(argp1);
10181 {
10182 PyThreadState* __tstate = wxPyBeginAllowThreads();
10183 result = (PyObject *)wxGridCellCoords_Get(arg1);
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 resultobj = result;
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 SWIGINTERN PyObject *GridCellCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10195 PyObject *obj;
10196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10197 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridCellCoords, SWIG_NewClientData(obj));
10198 return SWIG_Py_Void();
10199 }
10200
10201 SWIGINTERN PyObject *GridCellCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10202 return SWIG_Python_InitShadowInstance(args);
10203 }
10204
10205 SWIGINTERN PyObject *_wrap_new_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10206 PyObject *resultobj = 0;
10207 wxWindow *arg1 = (wxWindow *) 0 ;
10208 int arg2 = (int) -1 ;
10209 wxPoint const &arg3_defvalue = wxDefaultPosition ;
10210 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
10211 wxSize const &arg4_defvalue = wxDefaultSize ;
10212 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
10213 long arg5 = (long) wxWANTS_CHARS ;
10214 wxString const &arg6_defvalue = wxPyPanelNameStr ;
10215 wxString *arg6 = (wxString *) &arg6_defvalue ;
10216 wxGrid *result = 0 ;
10217 void *argp1 = 0 ;
10218 int res1 = 0 ;
10219 int val2 ;
10220 int ecode2 = 0 ;
10221 wxPoint temp3 ;
10222 wxSize temp4 ;
10223 long val5 ;
10224 int ecode5 = 0 ;
10225 bool temp6 = false ;
10226 PyObject * obj0 = 0 ;
10227 PyObject * obj1 = 0 ;
10228 PyObject * obj2 = 0 ;
10229 PyObject * obj3 = 0 ;
10230 PyObject * obj4 = 0 ;
10231 PyObject * obj5 = 0 ;
10232 char * kwnames[] = {
10233 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10234 };
10235
10236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10238 if (!SWIG_IsOK(res1)) {
10239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Grid" "', expected argument " "1"" of type '" "wxWindow *""'");
10240 }
10241 arg1 = reinterpret_cast< wxWindow * >(argp1);
10242 if (obj1) {
10243 ecode2 = SWIG_AsVal_int(obj1, &val2);
10244 if (!SWIG_IsOK(ecode2)) {
10245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Grid" "', expected argument " "2"" of type '" "int""'");
10246 }
10247 arg2 = static_cast< int >(val2);
10248 }
10249 if (obj2) {
10250 {
10251 arg3 = &temp3;
10252 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
10253 }
10254 }
10255 if (obj3) {
10256 {
10257 arg4 = &temp4;
10258 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
10259 }
10260 }
10261 if (obj4) {
10262 ecode5 = SWIG_AsVal_long(obj4, &val5);
10263 if (!SWIG_IsOK(ecode5)) {
10264 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Grid" "', expected argument " "5"" of type '" "long""'");
10265 }
10266 arg5 = static_cast< long >(val5);
10267 }
10268 if (obj5) {
10269 {
10270 arg6 = wxString_in_helper(obj5);
10271 if (arg6 == NULL) SWIG_fail;
10272 temp6 = true;
10273 }
10274 }
10275 {
10276 if (!wxPyCheckForApp()) SWIG_fail;
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 result = (wxGrid *)new wxGrid(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_NEW | 0 );
10283 {
10284 if (temp6)
10285 delete arg6;
10286 }
10287 return resultobj;
10288 fail:
10289 {
10290 if (temp6)
10291 delete arg6;
10292 }
10293 return NULL;
10294 }
10295
10296
10297 SWIGINTERN PyObject *_wrap_new_PreGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10298 PyObject *resultobj = 0;
10299 wxGrid *result = 0 ;
10300
10301 if (!SWIG_Python_UnpackTuple(args,"new_PreGrid",0,0,0)) SWIG_fail;
10302 {
10303 if (!wxPyCheckForApp()) SWIG_fail;
10304 PyThreadState* __tstate = wxPyBeginAllowThreads();
10305 result = (wxGrid *)new wxGrid();
10306 wxPyEndAllowThreads(__tstate);
10307 if (PyErr_Occurred()) SWIG_fail;
10308 }
10309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGrid, SWIG_POINTER_OWN | 0 );
10310 return resultobj;
10311 fail:
10312 return NULL;
10313 }
10314
10315
10316 SWIGINTERN PyObject *_wrap_Grid_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10317 PyObject *resultobj = 0;
10318 wxGrid *arg1 = (wxGrid *) 0 ;
10319 wxWindow *arg2 = (wxWindow *) 0 ;
10320 int arg3 = (int) -1 ;
10321 wxPoint const &arg4_defvalue = wxDefaultPosition ;
10322 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
10323 wxSize const &arg5_defvalue = wxDefaultSize ;
10324 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
10325 long arg6 = (long) wxWANTS_CHARS ;
10326 wxString const &arg7_defvalue = wxPyPanelNameStr ;
10327 wxString *arg7 = (wxString *) &arg7_defvalue ;
10328 bool result;
10329 void *argp1 = 0 ;
10330 int res1 = 0 ;
10331 void *argp2 = 0 ;
10332 int res2 = 0 ;
10333 int val3 ;
10334 int ecode3 = 0 ;
10335 wxPoint temp4 ;
10336 wxSize temp5 ;
10337 long val6 ;
10338 int ecode6 = 0 ;
10339 bool temp7 = false ;
10340 PyObject * obj0 = 0 ;
10341 PyObject * obj1 = 0 ;
10342 PyObject * obj2 = 0 ;
10343 PyObject * obj3 = 0 ;
10344 PyObject * obj4 = 0 ;
10345 PyObject * obj5 = 0 ;
10346 PyObject * obj6 = 0 ;
10347 char * kwnames[] = {
10348 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
10349 };
10350
10351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Grid_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10353 if (!SWIG_IsOK(res1)) {
10354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_Create" "', expected argument " "1"" of type '" "wxGrid *""'");
10355 }
10356 arg1 = reinterpret_cast< wxGrid * >(argp1);
10357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
10358 if (!SWIG_IsOK(res2)) {
10359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
10360 }
10361 arg2 = reinterpret_cast< wxWindow * >(argp2);
10362 if (obj2) {
10363 ecode3 = SWIG_AsVal_int(obj2, &val3);
10364 if (!SWIG_IsOK(ecode3)) {
10365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_Create" "', expected argument " "3"" of type '" "int""'");
10366 }
10367 arg3 = static_cast< int >(val3);
10368 }
10369 if (obj3) {
10370 {
10371 arg4 = &temp4;
10372 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
10373 }
10374 }
10375 if (obj4) {
10376 {
10377 arg5 = &temp5;
10378 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
10379 }
10380 }
10381 if (obj5) {
10382 ecode6 = SWIG_AsVal_long(obj5, &val6);
10383 if (!SWIG_IsOK(ecode6)) {
10384 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_Create" "', expected argument " "6"" of type '" "long""'");
10385 }
10386 arg6 = static_cast< long >(val6);
10387 }
10388 if (obj6) {
10389 {
10390 arg7 = wxString_in_helper(obj6);
10391 if (arg7 == NULL) SWIG_fail;
10392 temp7 = true;
10393 }
10394 }
10395 {
10396 PyThreadState* __tstate = wxPyBeginAllowThreads();
10397 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
10398 wxPyEndAllowThreads(__tstate);
10399 if (PyErr_Occurred()) SWIG_fail;
10400 }
10401 {
10402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10403 }
10404 {
10405 if (temp7)
10406 delete arg7;
10407 }
10408 return resultobj;
10409 fail:
10410 {
10411 if (temp7)
10412 delete arg7;
10413 }
10414 return NULL;
10415 }
10416
10417
10418 SWIGINTERN PyObject *_wrap_Grid_CreateGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10419 PyObject *resultobj = 0;
10420 wxGrid *arg1 = (wxGrid *) 0 ;
10421 int arg2 ;
10422 int arg3 ;
10423 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10424 bool result;
10425 void *argp1 = 0 ;
10426 int res1 = 0 ;
10427 int val2 ;
10428 int ecode2 = 0 ;
10429 int val3 ;
10430 int ecode3 = 0 ;
10431 int val4 ;
10432 int ecode4 = 0 ;
10433 PyObject * obj0 = 0 ;
10434 PyObject * obj1 = 0 ;
10435 PyObject * obj2 = 0 ;
10436 PyObject * obj3 = 0 ;
10437 char * kwnames[] = {
10438 (char *) "self",(char *) "numRows",(char *) "numCols",(char *) "selmode", NULL
10439 };
10440
10441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_CreateGrid",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10443 if (!SWIG_IsOK(res1)) {
10444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CreateGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10445 }
10446 arg1 = reinterpret_cast< wxGrid * >(argp1);
10447 ecode2 = SWIG_AsVal_int(obj1, &val2);
10448 if (!SWIG_IsOK(ecode2)) {
10449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CreateGrid" "', expected argument " "2"" of type '" "int""'");
10450 }
10451 arg2 = static_cast< int >(val2);
10452 ecode3 = SWIG_AsVal_int(obj2, &val3);
10453 if (!SWIG_IsOK(ecode3)) {
10454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CreateGrid" "', expected argument " "3"" of type '" "int""'");
10455 }
10456 arg3 = static_cast< int >(val3);
10457 if (obj3) {
10458 ecode4 = SWIG_AsVal_int(obj3, &val4);
10459 if (!SWIG_IsOK(ecode4)) {
10460 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_CreateGrid" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10461 }
10462 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10463 }
10464 {
10465 PyThreadState* __tstate = wxPyBeginAllowThreads();
10466 result = (bool)(arg1)->CreateGrid(arg2,arg3,arg4);
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 {
10471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10472 }
10473 return resultobj;
10474 fail:
10475 return NULL;
10476 }
10477
10478
10479 SWIGINTERN PyObject *_wrap_Grid_SetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10480 PyObject *resultobj = 0;
10481 wxGrid *arg1 = (wxGrid *) 0 ;
10482 WXGRIDSELECTIONMODES arg2 ;
10483 void *argp1 = 0 ;
10484 int res1 = 0 ;
10485 int val2 ;
10486 int ecode2 = 0 ;
10487 PyObject * obj0 = 0 ;
10488 PyObject * obj1 = 0 ;
10489 char * kwnames[] = {
10490 (char *) "self",(char *) "selmode", NULL
10491 };
10492
10493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionMode",kwnames,&obj0,&obj1)) SWIG_fail;
10494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10497 }
10498 arg1 = reinterpret_cast< wxGrid * >(argp1);
10499 ecode2 = SWIG_AsVal_int(obj1, &val2);
10500 if (!SWIG_IsOK(ecode2)) {
10501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetSelectionMode" "', expected argument " "2"" of type '" "WXGRIDSELECTIONMODES""'");
10502 }
10503 arg2 = static_cast< WXGRIDSELECTIONMODES >(val2);
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 (arg1)->SetSelectionMode(arg2);
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 resultobj = SWIG_Py_Void();
10511 return resultobj;
10512 fail:
10513 return NULL;
10514 }
10515
10516
10517 SWIGINTERN PyObject *_wrap_Grid_GetSelectionMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10518 PyObject *resultobj = 0;
10519 wxGrid *arg1 = (wxGrid *) 0 ;
10520 WXGRIDSELECTIONMODES result;
10521 void *argp1 = 0 ;
10522 int res1 = 0 ;
10523 PyObject *swig_obj[1] ;
10524
10525 if (!args) SWIG_fail;
10526 swig_obj[0] = args;
10527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10528 if (!SWIG_IsOK(res1)) {
10529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionMode" "', expected argument " "1"" of type '" "wxGrid *""'");
10530 }
10531 arg1 = reinterpret_cast< wxGrid * >(argp1);
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 result = (WXGRIDSELECTIONMODES)(arg1)->GetSelectionMode();
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 resultobj = SWIG_From_int(static_cast< int >(result));
10539 return resultobj;
10540 fail:
10541 return NULL;
10542 }
10543
10544
10545 SWIGINTERN PyObject *_wrap_Grid_GetNumberRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10546 PyObject *resultobj = 0;
10547 wxGrid *arg1 = (wxGrid *) 0 ;
10548 int result;
10549 void *argp1 = 0 ;
10550 int res1 = 0 ;
10551 PyObject *swig_obj[1] ;
10552
10553 if (!args) SWIG_fail;
10554 swig_obj[0] = args;
10555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10556 if (!SWIG_IsOK(res1)) {
10557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10558 }
10559 arg1 = reinterpret_cast< wxGrid * >(argp1);
10560 {
10561 PyThreadState* __tstate = wxPyBeginAllowThreads();
10562 result = (int)(arg1)->GetNumberRows();
10563 wxPyEndAllowThreads(__tstate);
10564 if (PyErr_Occurred()) SWIG_fail;
10565 }
10566 resultobj = SWIG_From_int(static_cast< int >(result));
10567 return resultobj;
10568 fail:
10569 return NULL;
10570 }
10571
10572
10573 SWIGINTERN PyObject *_wrap_Grid_GetNumberCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10574 PyObject *resultobj = 0;
10575 wxGrid *arg1 = (wxGrid *) 0 ;
10576 int result;
10577 void *argp1 = 0 ;
10578 int res1 = 0 ;
10579 PyObject *swig_obj[1] ;
10580
10581 if (!args) SWIG_fail;
10582 swig_obj[0] = args;
10583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10584 if (!SWIG_IsOK(res1)) {
10585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetNumberCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10586 }
10587 arg1 = reinterpret_cast< wxGrid * >(argp1);
10588 {
10589 PyThreadState* __tstate = wxPyBeginAllowThreads();
10590 result = (int)(arg1)->GetNumberCols();
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 resultobj = SWIG_From_int(static_cast< int >(result));
10595 return resultobj;
10596 fail:
10597 return NULL;
10598 }
10599
10600
10601 SWIGINTERN PyObject *_wrap_Grid_ProcessTableMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10602 PyObject *resultobj = 0;
10603 wxGrid *arg1 = (wxGrid *) 0 ;
10604 wxGridTableMessage *arg2 = 0 ;
10605 bool result;
10606 void *argp1 = 0 ;
10607 int res1 = 0 ;
10608 void *argp2 = 0 ;
10609 int res2 = 0 ;
10610 PyObject * obj0 = 0 ;
10611 PyObject * obj1 = 0 ;
10612 char * kwnames[] = {
10613 (char *) "self",(char *)"arg2", NULL
10614 };
10615
10616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_ProcessTableMessage",kwnames,&obj0,&obj1)) SWIG_fail;
10617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10618 if (!SWIG_IsOK(res1)) {
10619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ProcessTableMessage" "', expected argument " "1"" of type '" "wxGrid *""'");
10620 }
10621 arg1 = reinterpret_cast< wxGrid * >(argp1);
10622 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGridTableMessage, 0 );
10623 if (!SWIG_IsOK(res2)) {
10624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10625 }
10626 if (!argp2) {
10627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_ProcessTableMessage" "', expected argument " "2"" of type '" "wxGridTableMessage &""'");
10628 }
10629 arg2 = reinterpret_cast< wxGridTableMessage * >(argp2);
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = (bool)(arg1)->ProcessTableMessage(*arg2);
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 {
10637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10638 }
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 SWIGINTERN PyObject *_wrap_Grid_GetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10646 PyObject *resultobj = 0;
10647 wxGrid *arg1 = (wxGrid *) 0 ;
10648 wxGridTableBase *result = 0 ;
10649 void *argp1 = 0 ;
10650 int res1 = 0 ;
10651 PyObject *swig_obj[1] ;
10652
10653 if (!args) SWIG_fail;
10654 swig_obj[0] = args;
10655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10656 if (!SWIG_IsOK(res1)) {
10657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTable" "', expected argument " "1"" of type '" "wxGrid const *""'");
10658 }
10659 arg1 = reinterpret_cast< wxGrid * >(argp1);
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = (wxGridTableBase *)((wxGrid const *)arg1)->GetTable();
10663 wxPyEndAllowThreads(__tstate);
10664 if (PyErr_Occurred()) SWIG_fail;
10665 }
10666 {
10667 resultobj = wxPyMake_wxGridTableBase(result, (bool)0);
10668 }
10669 return resultobj;
10670 fail:
10671 return NULL;
10672 }
10673
10674
10675 SWIGINTERN PyObject *_wrap_Grid_SetTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj = 0;
10677 wxGrid *arg1 = (wxGrid *) 0 ;
10678 wxGridTableBase *arg2 = (wxGridTableBase *) 0 ;
10679 bool arg3 = (bool) false ;
10680 WXGRIDSELECTIONMODES arg4 = (WXGRIDSELECTIONMODES) wxGrid::wxGridSelectCells ;
10681 bool result;
10682 void *argp1 = 0 ;
10683 int res1 = 0 ;
10684 int res2 = 0 ;
10685 bool val3 ;
10686 int ecode3 = 0 ;
10687 int val4 ;
10688 int ecode4 = 0 ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 PyObject * obj3 = 0 ;
10693 char * kwnames[] = {
10694 (char *) "self",(char *) "table",(char *) "takeOwnership",(char *) "selmode", NULL
10695 };
10696
10697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetTable",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10699 if (!SWIG_IsOK(res1)) {
10700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetTable" "', expected argument " "1"" of type '" "wxGrid *""'");
10701 }
10702 arg1 = reinterpret_cast< wxGrid * >(argp1);
10703 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGridTableBase, SWIG_POINTER_DISOWN | 0 );
10704 if (!SWIG_IsOK(res2)) {
10705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetTable" "', expected argument " "2"" of type '" "wxGridTableBase *""'");
10706 }
10707 if (obj2) {
10708 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10709 if (!SWIG_IsOK(ecode3)) {
10710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetTable" "', expected argument " "3"" of type '" "bool""'");
10711 }
10712 arg3 = static_cast< bool >(val3);
10713 }
10714 if (obj3) {
10715 ecode4 = SWIG_AsVal_int(obj3, &val4);
10716 if (!SWIG_IsOK(ecode4)) {
10717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetTable" "', expected argument " "4"" of type '" "WXGRIDSELECTIONMODES""'");
10718 }
10719 arg4 = static_cast< WXGRIDSELECTIONMODES >(val4);
10720 }
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = (bool)(arg1)->SetTable(arg2,arg3,arg4);
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 {
10728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10729 }
10730 return resultobj;
10731 fail:
10732 return NULL;
10733 }
10734
10735
10736 SWIGINTERN PyObject *_wrap_Grid_ClearGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10737 PyObject *resultobj = 0;
10738 wxGrid *arg1 = (wxGrid *) 0 ;
10739 void *argp1 = 0 ;
10740 int res1 = 0 ;
10741 PyObject *swig_obj[1] ;
10742
10743 if (!args) SWIG_fail;
10744 swig_obj[0] = args;
10745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10746 if (!SWIG_IsOK(res1)) {
10747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearGrid" "', expected argument " "1"" of type '" "wxGrid *""'");
10748 }
10749 arg1 = reinterpret_cast< wxGrid * >(argp1);
10750 {
10751 PyThreadState* __tstate = wxPyBeginAllowThreads();
10752 (arg1)->ClearGrid();
10753 wxPyEndAllowThreads(__tstate);
10754 if (PyErr_Occurred()) SWIG_fail;
10755 }
10756 resultobj = SWIG_Py_Void();
10757 return resultobj;
10758 fail:
10759 return NULL;
10760 }
10761
10762
10763 SWIGINTERN PyObject *_wrap_Grid_InsertRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10764 PyObject *resultobj = 0;
10765 wxGrid *arg1 = (wxGrid *) 0 ;
10766 int arg2 = (int) 0 ;
10767 int arg3 = (int) 1 ;
10768 bool arg4 = (bool) true ;
10769 bool result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 int val2 ;
10773 int ecode2 = 0 ;
10774 int val3 ;
10775 int ecode3 = 0 ;
10776 bool val4 ;
10777 int ecode4 = 0 ;
10778 PyObject * obj0 = 0 ;
10779 PyObject * obj1 = 0 ;
10780 PyObject * obj2 = 0 ;
10781 PyObject * obj3 = 0 ;
10782 char * kwnames[] = {
10783 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10784 };
10785
10786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10788 if (!SWIG_IsOK(res1)) {
10789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10790 }
10791 arg1 = reinterpret_cast< wxGrid * >(argp1);
10792 if (obj1) {
10793 ecode2 = SWIG_AsVal_int(obj1, &val2);
10794 if (!SWIG_IsOK(ecode2)) {
10795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertRows" "', expected argument " "2"" of type '" "int""'");
10796 }
10797 arg2 = static_cast< int >(val2);
10798 }
10799 if (obj2) {
10800 ecode3 = SWIG_AsVal_int(obj2, &val3);
10801 if (!SWIG_IsOK(ecode3)) {
10802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertRows" "', expected argument " "3"" of type '" "int""'");
10803 }
10804 arg3 = static_cast< int >(val3);
10805 }
10806 if (obj3) {
10807 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10808 if (!SWIG_IsOK(ecode4)) {
10809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertRows" "', expected argument " "4"" of type '" "bool""'");
10810 }
10811 arg4 = static_cast< bool >(val4);
10812 }
10813 {
10814 PyThreadState* __tstate = wxPyBeginAllowThreads();
10815 result = (bool)(arg1)->InsertRows(arg2,arg3,arg4);
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 {
10820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10821 }
10822 return resultobj;
10823 fail:
10824 return NULL;
10825 }
10826
10827
10828 SWIGINTERN PyObject *_wrap_Grid_AppendRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10829 PyObject *resultobj = 0;
10830 wxGrid *arg1 = (wxGrid *) 0 ;
10831 int arg2 = (int) 1 ;
10832 bool arg3 = (bool) true ;
10833 bool result;
10834 void *argp1 = 0 ;
10835 int res1 = 0 ;
10836 int val2 ;
10837 int ecode2 = 0 ;
10838 bool val3 ;
10839 int ecode3 = 0 ;
10840 PyObject * obj0 = 0 ;
10841 PyObject * obj1 = 0 ;
10842 PyObject * obj2 = 0 ;
10843 char * kwnames[] = {
10844 (char *) "self",(char *) "numRows",(char *) "updateLabels", NULL
10845 };
10846
10847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendRows",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10849 if (!SWIG_IsOK(res1)) {
10850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10851 }
10852 arg1 = reinterpret_cast< wxGrid * >(argp1);
10853 if (obj1) {
10854 ecode2 = SWIG_AsVal_int(obj1, &val2);
10855 if (!SWIG_IsOK(ecode2)) {
10856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendRows" "', expected argument " "2"" of type '" "int""'");
10857 }
10858 arg2 = static_cast< int >(val2);
10859 }
10860 if (obj2) {
10861 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10862 if (!SWIG_IsOK(ecode3)) {
10863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendRows" "', expected argument " "3"" of type '" "bool""'");
10864 }
10865 arg3 = static_cast< bool >(val3);
10866 }
10867 {
10868 PyThreadState* __tstate = wxPyBeginAllowThreads();
10869 result = (bool)(arg1)->AppendRows(arg2,arg3);
10870 wxPyEndAllowThreads(__tstate);
10871 if (PyErr_Occurred()) SWIG_fail;
10872 }
10873 {
10874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10875 }
10876 return resultobj;
10877 fail:
10878 return NULL;
10879 }
10880
10881
10882 SWIGINTERN PyObject *_wrap_Grid_DeleteRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10883 PyObject *resultobj = 0;
10884 wxGrid *arg1 = (wxGrid *) 0 ;
10885 int arg2 = (int) 0 ;
10886 int arg3 = (int) 1 ;
10887 bool arg4 = (bool) true ;
10888 bool result;
10889 void *argp1 = 0 ;
10890 int res1 = 0 ;
10891 int val2 ;
10892 int ecode2 = 0 ;
10893 int val3 ;
10894 int ecode3 = 0 ;
10895 bool val4 ;
10896 int ecode4 = 0 ;
10897 PyObject * obj0 = 0 ;
10898 PyObject * obj1 = 0 ;
10899 PyObject * obj2 = 0 ;
10900 PyObject * obj3 = 0 ;
10901 char * kwnames[] = {
10902 (char *) "self",(char *) "pos",(char *) "numRows",(char *) "updateLabels", NULL
10903 };
10904
10905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteRows",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteRows" "', expected argument " "1"" of type '" "wxGrid *""'");
10909 }
10910 arg1 = reinterpret_cast< wxGrid * >(argp1);
10911 if (obj1) {
10912 ecode2 = SWIG_AsVal_int(obj1, &val2);
10913 if (!SWIG_IsOK(ecode2)) {
10914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteRows" "', expected argument " "2"" of type '" "int""'");
10915 }
10916 arg2 = static_cast< int >(val2);
10917 }
10918 if (obj2) {
10919 ecode3 = SWIG_AsVal_int(obj2, &val3);
10920 if (!SWIG_IsOK(ecode3)) {
10921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteRows" "', expected argument " "3"" of type '" "int""'");
10922 }
10923 arg3 = static_cast< int >(val3);
10924 }
10925 if (obj3) {
10926 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10927 if (!SWIG_IsOK(ecode4)) {
10928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteRows" "', expected argument " "4"" of type '" "bool""'");
10929 }
10930 arg4 = static_cast< bool >(val4);
10931 }
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 result = (bool)(arg1)->DeleteRows(arg2,arg3,arg4);
10935 wxPyEndAllowThreads(__tstate);
10936 if (PyErr_Occurred()) SWIG_fail;
10937 }
10938 {
10939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10940 }
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_Grid_InsertCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxGrid *arg1 = (wxGrid *) 0 ;
10950 int arg2 = (int) 0 ;
10951 int arg3 = (int) 1 ;
10952 bool arg4 = (bool) true ;
10953 bool result;
10954 void *argp1 = 0 ;
10955 int res1 = 0 ;
10956 int val2 ;
10957 int ecode2 = 0 ;
10958 int val3 ;
10959 int ecode3 = 0 ;
10960 bool val4 ;
10961 int ecode4 = 0 ;
10962 PyObject * obj0 = 0 ;
10963 PyObject * obj1 = 0 ;
10964 PyObject * obj2 = 0 ;
10965 PyObject * obj3 = 0 ;
10966 char * kwnames[] = {
10967 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
10968 };
10969
10970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_InsertCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_InsertCols" "', expected argument " "1"" of type '" "wxGrid *""'");
10974 }
10975 arg1 = reinterpret_cast< wxGrid * >(argp1);
10976 if (obj1) {
10977 ecode2 = SWIG_AsVal_int(obj1, &val2);
10978 if (!SWIG_IsOK(ecode2)) {
10979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_InsertCols" "', expected argument " "2"" of type '" "int""'");
10980 }
10981 arg2 = static_cast< int >(val2);
10982 }
10983 if (obj2) {
10984 ecode3 = SWIG_AsVal_int(obj2, &val3);
10985 if (!SWIG_IsOK(ecode3)) {
10986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_InsertCols" "', expected argument " "3"" of type '" "int""'");
10987 }
10988 arg3 = static_cast< int >(val3);
10989 }
10990 if (obj3) {
10991 ecode4 = SWIG_AsVal_bool(obj3, &val4);
10992 if (!SWIG_IsOK(ecode4)) {
10993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_InsertCols" "', expected argument " "4"" of type '" "bool""'");
10994 }
10995 arg4 = static_cast< bool >(val4);
10996 }
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 result = (bool)(arg1)->InsertCols(arg2,arg3,arg4);
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11005 }
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 SWIGINTERN PyObject *_wrap_Grid_AppendCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11013 PyObject *resultobj = 0;
11014 wxGrid *arg1 = (wxGrid *) 0 ;
11015 int arg2 = (int) 1 ;
11016 bool arg3 = (bool) true ;
11017 bool result;
11018 void *argp1 = 0 ;
11019 int res1 = 0 ;
11020 int val2 ;
11021 int ecode2 = 0 ;
11022 bool val3 ;
11023 int ecode3 = 0 ;
11024 PyObject * obj0 = 0 ;
11025 PyObject * obj1 = 0 ;
11026 PyObject * obj2 = 0 ;
11027 char * kwnames[] = {
11028 (char *) "self",(char *) "numCols",(char *) "updateLabels", NULL
11029 };
11030
11031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Grid_AppendCols",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11033 if (!SWIG_IsOK(res1)) {
11034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AppendCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11035 }
11036 arg1 = reinterpret_cast< wxGrid * >(argp1);
11037 if (obj1) {
11038 ecode2 = SWIG_AsVal_int(obj1, &val2);
11039 if (!SWIG_IsOK(ecode2)) {
11040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AppendCols" "', expected argument " "2"" of type '" "int""'");
11041 }
11042 arg2 = static_cast< int >(val2);
11043 }
11044 if (obj2) {
11045 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11046 if (!SWIG_IsOK(ecode3)) {
11047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AppendCols" "', expected argument " "3"" of type '" "bool""'");
11048 }
11049 arg3 = static_cast< bool >(val3);
11050 }
11051 {
11052 PyThreadState* __tstate = wxPyBeginAllowThreads();
11053 result = (bool)(arg1)->AppendCols(arg2,arg3);
11054 wxPyEndAllowThreads(__tstate);
11055 if (PyErr_Occurred()) SWIG_fail;
11056 }
11057 {
11058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11059 }
11060 return resultobj;
11061 fail:
11062 return NULL;
11063 }
11064
11065
11066 SWIGINTERN PyObject *_wrap_Grid_DeleteCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11067 PyObject *resultobj = 0;
11068 wxGrid *arg1 = (wxGrid *) 0 ;
11069 int arg2 = (int) 0 ;
11070 int arg3 = (int) 1 ;
11071 bool arg4 = (bool) true ;
11072 bool result;
11073 void *argp1 = 0 ;
11074 int res1 = 0 ;
11075 int val2 ;
11076 int ecode2 = 0 ;
11077 int val3 ;
11078 int ecode3 = 0 ;
11079 bool val4 ;
11080 int ecode4 = 0 ;
11081 PyObject * obj0 = 0 ;
11082 PyObject * obj1 = 0 ;
11083 PyObject * obj2 = 0 ;
11084 PyObject * obj3 = 0 ;
11085 char * kwnames[] = {
11086 (char *) "self",(char *) "pos",(char *) "numCols",(char *) "updateLabels", NULL
11087 };
11088
11089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Grid_DeleteCols",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11091 if (!SWIG_IsOK(res1)) {
11092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeleteCols" "', expected argument " "1"" of type '" "wxGrid *""'");
11093 }
11094 arg1 = reinterpret_cast< wxGrid * >(argp1);
11095 if (obj1) {
11096 ecode2 = SWIG_AsVal_int(obj1, &val2);
11097 if (!SWIG_IsOK(ecode2)) {
11098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeleteCols" "', expected argument " "2"" of type '" "int""'");
11099 }
11100 arg2 = static_cast< int >(val2);
11101 }
11102 if (obj2) {
11103 ecode3 = SWIG_AsVal_int(obj2, &val3);
11104 if (!SWIG_IsOK(ecode3)) {
11105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeleteCols" "', expected argument " "3"" of type '" "int""'");
11106 }
11107 arg3 = static_cast< int >(val3);
11108 }
11109 if (obj3) {
11110 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11111 if (!SWIG_IsOK(ecode4)) {
11112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_DeleteCols" "', expected argument " "4"" of type '" "bool""'");
11113 }
11114 arg4 = static_cast< bool >(val4);
11115 }
11116 {
11117 PyThreadState* __tstate = wxPyBeginAllowThreads();
11118 result = (bool)(arg1)->DeleteCols(arg2,arg3,arg4);
11119 wxPyEndAllowThreads(__tstate);
11120 if (PyErr_Occurred()) SWIG_fail;
11121 }
11122 {
11123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11124 }
11125 return resultobj;
11126 fail:
11127 return NULL;
11128 }
11129
11130
11131 SWIGINTERN PyObject *_wrap_Grid_DrawCellHighlight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11132 PyObject *resultobj = 0;
11133 wxGrid *arg1 = (wxGrid *) 0 ;
11134 wxDC *arg2 = 0 ;
11135 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
11136 void *argp1 = 0 ;
11137 int res1 = 0 ;
11138 void *argp2 = 0 ;
11139 int res2 = 0 ;
11140 void *argp3 = 0 ;
11141 int res3 = 0 ;
11142 PyObject * obj0 = 0 ;
11143 PyObject * obj1 = 0 ;
11144 PyObject * obj2 = 0 ;
11145 char * kwnames[] = {
11146 (char *) "self",(char *) "dc",(char *) "attr", NULL
11147 };
11148
11149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DrawCellHighlight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawCellHighlight" "', expected argument " "1"" of type '" "wxGrid *""'");
11153 }
11154 arg1 = reinterpret_cast< wxGrid * >(argp1);
11155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11156 if (!SWIG_IsOK(res2)) {
11157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11158 }
11159 if (!argp2) {
11160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawCellHighlight" "', expected argument " "2"" of type '" "wxDC &""'");
11161 }
11162 arg2 = reinterpret_cast< wxDC * >(argp2);
11163 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
11164 if (!SWIG_IsOK(res3)) {
11165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_DrawCellHighlight" "', expected argument " "3"" of type '" "wxGridCellAttr const *""'");
11166 }
11167 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
11168 {
11169 PyThreadState* __tstate = wxPyBeginAllowThreads();
11170 (arg1)->DrawCellHighlight(*arg2,(wxGridCellAttr const *)arg3);
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 resultobj = SWIG_Py_Void();
11175 return resultobj;
11176 fail:
11177 return NULL;
11178 }
11179
11180
11181 SWIGINTERN PyObject *_wrap_Grid_DrawTextRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11182 PyObject *resultobj = 0;
11183 wxGrid *arg1 = (wxGrid *) 0 ;
11184 wxDC *arg2 = 0 ;
11185 wxString *arg3 = 0 ;
11186 wxRect *arg4 = 0 ;
11187 int arg5 = (int) wxLEFT ;
11188 int arg6 = (int) wxTOP ;
11189 int arg7 = (int) wxHORIZONTAL ;
11190 void *argp1 = 0 ;
11191 int res1 = 0 ;
11192 void *argp2 = 0 ;
11193 int res2 = 0 ;
11194 bool temp3 = false ;
11195 wxRect temp4 ;
11196 int val5 ;
11197 int ecode5 = 0 ;
11198 int val6 ;
11199 int ecode6 = 0 ;
11200 int val7 ;
11201 int ecode7 = 0 ;
11202 PyObject * obj0 = 0 ;
11203 PyObject * obj1 = 0 ;
11204 PyObject * obj2 = 0 ;
11205 PyObject * obj3 = 0 ;
11206 PyObject * obj4 = 0 ;
11207 PyObject * obj5 = 0 ;
11208 PyObject * obj6 = 0 ;
11209 char * kwnames[] = {
11210 (char *) "self",(char *) "dc",(char *)"arg3",(char *)"arg4",(char *) "horizontalAlignment",(char *) "verticalAlignment",(char *) "textOrientation", NULL
11211 };
11212
11213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:Grid_DrawTextRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11215 if (!SWIG_IsOK(res1)) {
11216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DrawTextRectangle" "', expected argument " "1"" of type '" "wxGrid *""'");
11217 }
11218 arg1 = reinterpret_cast< wxGrid * >(argp1);
11219 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11220 if (!SWIG_IsOK(res2)) {
11221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11222 }
11223 if (!argp2) {
11224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_DrawTextRectangle" "', expected argument " "2"" of type '" "wxDC &""'");
11225 }
11226 arg2 = reinterpret_cast< wxDC * >(argp2);
11227 {
11228 arg3 = wxString_in_helper(obj2);
11229 if (arg3 == NULL) SWIG_fail;
11230 temp3 = true;
11231 }
11232 {
11233 arg4 = &temp4;
11234 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
11235 }
11236 if (obj4) {
11237 ecode5 = SWIG_AsVal_int(obj4, &val5);
11238 if (!SWIG_IsOK(ecode5)) {
11239 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_DrawTextRectangle" "', expected argument " "5"" of type '" "int""'");
11240 }
11241 arg5 = static_cast< int >(val5);
11242 }
11243 if (obj5) {
11244 ecode6 = SWIG_AsVal_int(obj5, &val6);
11245 if (!SWIG_IsOK(ecode6)) {
11246 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_DrawTextRectangle" "', expected argument " "6"" of type '" "int""'");
11247 }
11248 arg6 = static_cast< int >(val6);
11249 }
11250 if (obj6) {
11251 ecode7 = SWIG_AsVal_int(obj6, &val7);
11252 if (!SWIG_IsOK(ecode7)) {
11253 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Grid_DrawTextRectangle" "', expected argument " "7"" of type '" "int""'");
11254 }
11255 arg7 = static_cast< int >(val7);
11256 }
11257 {
11258 PyThreadState* __tstate = wxPyBeginAllowThreads();
11259 (arg1)->DrawTextRectangle(*arg2,(wxString const &)*arg3,(wxRect const &)*arg4,arg5,arg6,arg7);
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 resultobj = SWIG_Py_Void();
11264 {
11265 if (temp3)
11266 delete arg3;
11267 }
11268 return resultobj;
11269 fail:
11270 {
11271 if (temp3)
11272 delete arg3;
11273 }
11274 return NULL;
11275 }
11276
11277
11278 SWIGINTERN PyObject *_wrap_Grid_GetTextBoxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11279 PyObject *resultobj = 0;
11280 wxGrid *arg1 = (wxGrid *) 0 ;
11281 wxDC *arg2 = 0 ;
11282 wxArrayString *arg3 = 0 ;
11283 long *arg4 = (long *) 0 ;
11284 long *arg5 = (long *) 0 ;
11285 void *argp1 = 0 ;
11286 int res1 = 0 ;
11287 void *argp2 = 0 ;
11288 int res2 = 0 ;
11289 bool temp3 = false ;
11290 long temp4 ;
11291 int res4 = SWIG_TMPOBJ ;
11292 long temp5 ;
11293 int res5 = SWIG_TMPOBJ ;
11294 PyObject * obj0 = 0 ;
11295 PyObject * obj1 = 0 ;
11296 PyObject * obj2 = 0 ;
11297 char * kwnames[] = {
11298 (char *) "self",(char *) "dc",(char *) "lines", NULL
11299 };
11300
11301 arg4 = &temp4;
11302 arg5 = &temp5;
11303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetTextBoxSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11305 if (!SWIG_IsOK(res1)) {
11306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetTextBoxSize" "', expected argument " "1"" of type '" "wxGrid *""'");
11307 }
11308 arg1 = reinterpret_cast< wxGrid * >(argp1);
11309 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
11310 if (!SWIG_IsOK(res2)) {
11311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11312 }
11313 if (!argp2) {
11314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_GetTextBoxSize" "', expected argument " "2"" of type '" "wxDC &""'");
11315 }
11316 arg2 = reinterpret_cast< wxDC * >(argp2);
11317 {
11318 if (! PySequence_Check(obj2)) {
11319 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
11320 SWIG_fail;
11321 }
11322 arg3 = new wxArrayString;
11323 temp3 = true;
11324 int i, len=PySequence_Length(obj2);
11325 for (i=0; i<len; i++) {
11326 PyObject* item = PySequence_GetItem(obj2, i);
11327 wxString* s = wxString_in_helper(item);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 arg3->Add(*s);
11330 delete s;
11331 Py_DECREF(item);
11332 }
11333 }
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 (arg1)->GetTextBoxSize(*arg2,*arg3,arg4,arg5);
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 if (SWIG_IsTmpObj(res4)) {
11342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));
11343 } else {
11344 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));
11346 }
11347 if (SWIG_IsTmpObj(res5)) {
11348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg5)));
11349 } else {
11350 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags));
11352 }
11353 {
11354 if (temp3) delete arg3;
11355 }
11356 return resultobj;
11357 fail:
11358 {
11359 if (temp3) delete arg3;
11360 }
11361 return NULL;
11362 }
11363
11364
11365 SWIGINTERN PyObject *_wrap_Grid_BeginBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11366 PyObject *resultobj = 0;
11367 wxGrid *arg1 = (wxGrid *) 0 ;
11368 void *argp1 = 0 ;
11369 int res1 = 0 ;
11370 PyObject *swig_obj[1] ;
11371
11372 if (!args) SWIG_fail;
11373 swig_obj[0] = args;
11374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11375 if (!SWIG_IsOK(res1)) {
11376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BeginBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11377 }
11378 arg1 = reinterpret_cast< wxGrid * >(argp1);
11379 {
11380 PyThreadState* __tstate = wxPyBeginAllowThreads();
11381 (arg1)->BeginBatch();
11382 wxPyEndAllowThreads(__tstate);
11383 if (PyErr_Occurred()) SWIG_fail;
11384 }
11385 resultobj = SWIG_Py_Void();
11386 return resultobj;
11387 fail:
11388 return NULL;
11389 }
11390
11391
11392 SWIGINTERN PyObject *_wrap_Grid_EndBatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11393 PyObject *resultobj = 0;
11394 wxGrid *arg1 = (wxGrid *) 0 ;
11395 void *argp1 = 0 ;
11396 int res1 = 0 ;
11397 PyObject *swig_obj[1] ;
11398
11399 if (!args) SWIG_fail;
11400 swig_obj[0] = args;
11401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11402 if (!SWIG_IsOK(res1)) {
11403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EndBatch" "', expected argument " "1"" of type '" "wxGrid *""'");
11404 }
11405 arg1 = reinterpret_cast< wxGrid * >(argp1);
11406 {
11407 PyThreadState* __tstate = wxPyBeginAllowThreads();
11408 (arg1)->EndBatch();
11409 wxPyEndAllowThreads(__tstate);
11410 if (PyErr_Occurred()) SWIG_fail;
11411 }
11412 resultobj = SWIG_Py_Void();
11413 return resultobj;
11414 fail:
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *_wrap_Grid_GetBatchCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11420 PyObject *resultobj = 0;
11421 wxGrid *arg1 = (wxGrid *) 0 ;
11422 int result;
11423 void *argp1 = 0 ;
11424 int res1 = 0 ;
11425 PyObject *swig_obj[1] ;
11426
11427 if (!args) SWIG_fail;
11428 swig_obj[0] = args;
11429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11430 if (!SWIG_IsOK(res1)) {
11431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetBatchCount" "', expected argument " "1"" of type '" "wxGrid *""'");
11432 }
11433 arg1 = reinterpret_cast< wxGrid * >(argp1);
11434 {
11435 PyThreadState* __tstate = wxPyBeginAllowThreads();
11436 result = (int)(arg1)->GetBatchCount();
11437 wxPyEndAllowThreads(__tstate);
11438 if (PyErr_Occurred()) SWIG_fail;
11439 }
11440 resultobj = SWIG_From_int(static_cast< int >(result));
11441 return resultobj;
11442 fail:
11443 return NULL;
11444 }
11445
11446
11447 SWIGINTERN PyObject *_wrap_Grid_ForceRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11448 PyObject *resultobj = 0;
11449 wxGrid *arg1 = (wxGrid *) 0 ;
11450 void *argp1 = 0 ;
11451 int res1 = 0 ;
11452 PyObject *swig_obj[1] ;
11453
11454 if (!args) SWIG_fail;
11455 swig_obj[0] = args;
11456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11457 if (!SWIG_IsOK(res1)) {
11458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ForceRefresh" "', expected argument " "1"" of type '" "wxGrid *""'");
11459 }
11460 arg1 = reinterpret_cast< wxGrid * >(argp1);
11461 {
11462 PyThreadState* __tstate = wxPyBeginAllowThreads();
11463 (arg1)->ForceRefresh();
11464 wxPyEndAllowThreads(__tstate);
11465 if (PyErr_Occurred()) SWIG_fail;
11466 }
11467 resultobj = SWIG_Py_Void();
11468 return resultobj;
11469 fail:
11470 return NULL;
11471 }
11472
11473
11474 SWIGINTERN PyObject *_wrap_Grid_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11475 PyObject *resultobj = 0;
11476 wxGrid *arg1 = (wxGrid *) 0 ;
11477 bool result;
11478 void *argp1 = 0 ;
11479 int res1 = 0 ;
11480 PyObject *swig_obj[1] ;
11481
11482 if (!args) SWIG_fail;
11483 swig_obj[0] = args;
11484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11485 if (!SWIG_IsOK(res1)) {
11486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsEditable" "', expected argument " "1"" of type '" "wxGrid *""'");
11487 }
11488 arg1 = reinterpret_cast< wxGrid * >(argp1);
11489 {
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (bool)(arg1)->IsEditable();
11492 wxPyEndAllowThreads(__tstate);
11493 if (PyErr_Occurred()) SWIG_fail;
11494 }
11495 {
11496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11497 }
11498 return resultobj;
11499 fail:
11500 return NULL;
11501 }
11502
11503
11504 SWIGINTERN PyObject *_wrap_Grid_EnableEditing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11505 PyObject *resultobj = 0;
11506 wxGrid *arg1 = (wxGrid *) 0 ;
11507 bool arg2 ;
11508 void *argp1 = 0 ;
11509 int res1 = 0 ;
11510 bool val2 ;
11511 int ecode2 = 0 ;
11512 PyObject * obj0 = 0 ;
11513 PyObject * obj1 = 0 ;
11514 char * kwnames[] = {
11515 (char *) "self",(char *) "edit", NULL
11516 };
11517
11518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_EnableEditing",kwnames,&obj0,&obj1)) SWIG_fail;
11519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11520 if (!SWIG_IsOK(res1)) {
11521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableEditing" "', expected argument " "1"" of type '" "wxGrid *""'");
11522 }
11523 arg1 = reinterpret_cast< wxGrid * >(argp1);
11524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11525 if (!SWIG_IsOK(ecode2)) {
11526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableEditing" "', expected argument " "2"" of type '" "bool""'");
11527 }
11528 arg2 = static_cast< bool >(val2);
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 (arg1)->EnableEditing(arg2);
11532 wxPyEndAllowThreads(__tstate);
11533 if (PyErr_Occurred()) SWIG_fail;
11534 }
11535 resultobj = SWIG_Py_Void();
11536 return resultobj;
11537 fail:
11538 return NULL;
11539 }
11540
11541
11542 SWIGINTERN PyObject *_wrap_Grid_EnableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11543 PyObject *resultobj = 0;
11544 wxGrid *arg1 = (wxGrid *) 0 ;
11545 bool arg2 = (bool) true ;
11546 void *argp1 = 0 ;
11547 int res1 = 0 ;
11548 bool val2 ;
11549 int ecode2 = 0 ;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 char * kwnames[] = {
11553 (char *) "self",(char *) "enable", NULL
11554 };
11555
11556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableCellEditControl",kwnames,&obj0,&obj1)) SWIG_fail;
11557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11558 if (!SWIG_IsOK(res1)) {
11559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11560 }
11561 arg1 = reinterpret_cast< wxGrid * >(argp1);
11562 if (obj1) {
11563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11564 if (!SWIG_IsOK(ecode2)) {
11565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableCellEditControl" "', expected argument " "2"" of type '" "bool""'");
11566 }
11567 arg2 = static_cast< bool >(val2);
11568 }
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 (arg1)->EnableCellEditControl(arg2);
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 resultobj = SWIG_Py_Void();
11576 return resultobj;
11577 fail:
11578 return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_Grid_DisableCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11583 PyObject *resultobj = 0;
11584 wxGrid *arg1 = (wxGrid *) 0 ;
11585 void *argp1 = 0 ;
11586 int res1 = 0 ;
11587 PyObject *swig_obj[1] ;
11588
11589 if (!args) SWIG_fail;
11590 swig_obj[0] = args;
11591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11592 if (!SWIG_IsOK(res1)) {
11593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11594 }
11595 arg1 = reinterpret_cast< wxGrid * >(argp1);
11596 {
11597 PyThreadState* __tstate = wxPyBeginAllowThreads();
11598 (arg1)->DisableCellEditControl();
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 resultobj = SWIG_Py_Void();
11603 return resultobj;
11604 fail:
11605 return NULL;
11606 }
11607
11608
11609 SWIGINTERN PyObject *_wrap_Grid_CanEnableCellControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11610 PyObject *resultobj = 0;
11611 wxGrid *arg1 = (wxGrid *) 0 ;
11612 bool result;
11613 void *argp1 = 0 ;
11614 int res1 = 0 ;
11615 PyObject *swig_obj[1] ;
11616
11617 if (!args) SWIG_fail;
11618 swig_obj[0] = args;
11619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11620 if (!SWIG_IsOK(res1)) {
11621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanEnableCellControl" "', expected argument " "1"" of type '" "wxGrid const *""'");
11622 }
11623 arg1 = reinterpret_cast< wxGrid * >(argp1);
11624 {
11625 PyThreadState* __tstate = wxPyBeginAllowThreads();
11626 result = (bool)((wxGrid const *)arg1)->CanEnableCellControl();
11627 wxPyEndAllowThreads(__tstate);
11628 if (PyErr_Occurred()) SWIG_fail;
11629 }
11630 {
11631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11632 }
11633 return resultobj;
11634 fail:
11635 return NULL;
11636 }
11637
11638
11639 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11640 PyObject *resultobj = 0;
11641 wxGrid *arg1 = (wxGrid *) 0 ;
11642 bool result;
11643 void *argp1 = 0 ;
11644 int res1 = 0 ;
11645 PyObject *swig_obj[1] ;
11646
11647 if (!args) SWIG_fail;
11648 swig_obj[0] = args;
11649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlEnabled" "', expected argument " "1"" of type '" "wxGrid const *""'");
11652 }
11653 arg1 = reinterpret_cast< wxGrid * >(argp1);
11654 {
11655 PyThreadState* __tstate = wxPyBeginAllowThreads();
11656 result = (bool)((wxGrid const *)arg1)->IsCellEditControlEnabled();
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11662 }
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 SWIGINTERN PyObject *_wrap_Grid_IsCellEditControlShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11670 PyObject *resultobj = 0;
11671 wxGrid *arg1 = (wxGrid *) 0 ;
11672 bool result;
11673 void *argp1 = 0 ;
11674 int res1 = 0 ;
11675 PyObject *swig_obj[1] ;
11676
11677 if (!args) SWIG_fail;
11678 swig_obj[0] = args;
11679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11680 if (!SWIG_IsOK(res1)) {
11681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCellEditControlShown" "', expected argument " "1"" of type '" "wxGrid const *""'");
11682 }
11683 arg1 = reinterpret_cast< wxGrid * >(argp1);
11684 {
11685 PyThreadState* __tstate = wxPyBeginAllowThreads();
11686 result = (bool)((wxGrid const *)arg1)->IsCellEditControlShown();
11687 wxPyEndAllowThreads(__tstate);
11688 if (PyErr_Occurred()) SWIG_fail;
11689 }
11690 {
11691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11692 }
11693 return resultobj;
11694 fail:
11695 return NULL;
11696 }
11697
11698
11699 SWIGINTERN PyObject *_wrap_Grid_IsCurrentCellReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11700 PyObject *resultobj = 0;
11701 wxGrid *arg1 = (wxGrid *) 0 ;
11702 bool result;
11703 void *argp1 = 0 ;
11704 int res1 = 0 ;
11705 PyObject *swig_obj[1] ;
11706
11707 if (!args) SWIG_fail;
11708 swig_obj[0] = args;
11709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11710 if (!SWIG_IsOK(res1)) {
11711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsCurrentCellReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
11712 }
11713 arg1 = reinterpret_cast< wxGrid * >(argp1);
11714 {
11715 PyThreadState* __tstate = wxPyBeginAllowThreads();
11716 result = (bool)((wxGrid const *)arg1)->IsCurrentCellReadOnly();
11717 wxPyEndAllowThreads(__tstate);
11718 if (PyErr_Occurred()) SWIG_fail;
11719 }
11720 {
11721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11722 }
11723 return resultobj;
11724 fail:
11725 return NULL;
11726 }
11727
11728
11729 SWIGINTERN PyObject *_wrap_Grid_ShowCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11730 PyObject *resultobj = 0;
11731 wxGrid *arg1 = (wxGrid *) 0 ;
11732 void *argp1 = 0 ;
11733 int res1 = 0 ;
11734 PyObject *swig_obj[1] ;
11735
11736 if (!args) SWIG_fail;
11737 swig_obj[0] = args;
11738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11739 if (!SWIG_IsOK(res1)) {
11740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ShowCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11741 }
11742 arg1 = reinterpret_cast< wxGrid * >(argp1);
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 (arg1)->ShowCellEditControl();
11746 wxPyEndAllowThreads(__tstate);
11747 if (PyErr_Occurred()) SWIG_fail;
11748 }
11749 resultobj = SWIG_Py_Void();
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 SWIGINTERN PyObject *_wrap_Grid_HideCellEditControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11757 PyObject *resultobj = 0;
11758 wxGrid *arg1 = (wxGrid *) 0 ;
11759 void *argp1 = 0 ;
11760 int res1 = 0 ;
11761 PyObject *swig_obj[1] ;
11762
11763 if (!args) SWIG_fail;
11764 swig_obj[0] = args;
11765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_HideCellEditControl" "', expected argument " "1"" of type '" "wxGrid *""'");
11768 }
11769 arg1 = reinterpret_cast< wxGrid * >(argp1);
11770 {
11771 PyThreadState* __tstate = wxPyBeginAllowThreads();
11772 (arg1)->HideCellEditControl();
11773 wxPyEndAllowThreads(__tstate);
11774 if (PyErr_Occurred()) SWIG_fail;
11775 }
11776 resultobj = SWIG_Py_Void();
11777 return resultobj;
11778 fail:
11779 return NULL;
11780 }
11781
11782
11783 SWIGINTERN PyObject *_wrap_Grid_SaveEditControlValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11784 PyObject *resultobj = 0;
11785 wxGrid *arg1 = (wxGrid *) 0 ;
11786 void *argp1 = 0 ;
11787 int res1 = 0 ;
11788 PyObject *swig_obj[1] ;
11789
11790 if (!args) SWIG_fail;
11791 swig_obj[0] = args;
11792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11793 if (!SWIG_IsOK(res1)) {
11794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SaveEditControlValue" "', expected argument " "1"" of type '" "wxGrid *""'");
11795 }
11796 arg1 = reinterpret_cast< wxGrid * >(argp1);
11797 {
11798 PyThreadState* __tstate = wxPyBeginAllowThreads();
11799 (arg1)->SaveEditControlValue();
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 resultobj = SWIG_Py_Void();
11804 return resultobj;
11805 fail:
11806 return NULL;
11807 }
11808
11809
11810 SWIGINTERN PyObject *_wrap_Grid_XYToCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj = 0;
11812 wxGrid *arg1 = (wxGrid *) 0 ;
11813 int arg2 ;
11814 int arg3 ;
11815 wxGridCellCoords result;
11816 void *argp1 = 0 ;
11817 int res1 = 0 ;
11818 int val2 ;
11819 int ecode2 = 0 ;
11820 int val3 ;
11821 int ecode3 = 0 ;
11822 PyObject * obj0 = 0 ;
11823 PyObject * obj1 = 0 ;
11824 PyObject * obj2 = 0 ;
11825 char * kwnames[] = {
11826 (char *) "self",(char *) "x",(char *) "y", NULL
11827 };
11828
11829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_XYToCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11831 if (!SWIG_IsOK(res1)) {
11832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XYToCell" "', expected argument " "1"" of type '" "wxGrid *""'");
11833 }
11834 arg1 = reinterpret_cast< wxGrid * >(argp1);
11835 ecode2 = SWIG_AsVal_int(obj1, &val2);
11836 if (!SWIG_IsOK(ecode2)) {
11837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XYToCell" "', expected argument " "2"" of type '" "int""'");
11838 }
11839 arg2 = static_cast< int >(val2);
11840 ecode3 = SWIG_AsVal_int(obj2, &val3);
11841 if (!SWIG_IsOK(ecode3)) {
11842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_XYToCell" "', expected argument " "3"" of type '" "int""'");
11843 }
11844 arg3 = static_cast< int >(val3);
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = wxGrid_XYToCell(arg1,arg2,arg3);
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
11852 return resultobj;
11853 fail:
11854 return NULL;
11855 }
11856
11857
11858 SWIGINTERN PyObject *_wrap_Grid_YToRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11859 PyObject *resultobj = 0;
11860 wxGrid *arg1 = (wxGrid *) 0 ;
11861 int arg2 ;
11862 int result;
11863 void *argp1 = 0 ;
11864 int res1 = 0 ;
11865 int val2 ;
11866 int ecode2 = 0 ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 char * kwnames[] = {
11870 (char *) "self",(char *) "y", NULL
11871 };
11872
11873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToRow",kwnames,&obj0,&obj1)) SWIG_fail;
11874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11877 }
11878 arg1 = reinterpret_cast< wxGrid * >(argp1);
11879 ecode2 = SWIG_AsVal_int(obj1, &val2);
11880 if (!SWIG_IsOK(ecode2)) {
11881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToRow" "', expected argument " "2"" of type '" "int""'");
11882 }
11883 arg2 = static_cast< int >(val2);
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = (int)(arg1)->YToRow(arg2);
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 resultobj = SWIG_From_int(static_cast< int >(result));
11891 return resultobj;
11892 fail:
11893 return NULL;
11894 }
11895
11896
11897 SWIGINTERN PyObject *_wrap_Grid_XToCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11898 PyObject *resultobj = 0;
11899 wxGrid *arg1 = (wxGrid *) 0 ;
11900 int arg2 ;
11901 int result;
11902 void *argp1 = 0 ;
11903 int res1 = 0 ;
11904 int val2 ;
11905 int ecode2 = 0 ;
11906 PyObject * obj0 = 0 ;
11907 PyObject * obj1 = 0 ;
11908 char * kwnames[] = {
11909 (char *) "self",(char *) "x", NULL
11910 };
11911
11912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToCol",kwnames,&obj0,&obj1)) SWIG_fail;
11913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11914 if (!SWIG_IsOK(res1)) {
11915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11916 }
11917 arg1 = reinterpret_cast< wxGrid * >(argp1);
11918 ecode2 = SWIG_AsVal_int(obj1, &val2);
11919 if (!SWIG_IsOK(ecode2)) {
11920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToCol" "', expected argument " "2"" of type '" "int""'");
11921 }
11922 arg2 = static_cast< int >(val2);
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 result = (int)(arg1)->XToCol(arg2);
11926 wxPyEndAllowThreads(__tstate);
11927 if (PyErr_Occurred()) SWIG_fail;
11928 }
11929 resultobj = SWIG_From_int(static_cast< int >(result));
11930 return resultobj;
11931 fail:
11932 return NULL;
11933 }
11934
11935
11936 SWIGINTERN PyObject *_wrap_Grid_YToEdgeOfRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11937 PyObject *resultobj = 0;
11938 wxGrid *arg1 = (wxGrid *) 0 ;
11939 int arg2 ;
11940 int result;
11941 void *argp1 = 0 ;
11942 int res1 = 0 ;
11943 int val2 ;
11944 int ecode2 = 0 ;
11945 PyObject * obj0 = 0 ;
11946 PyObject * obj1 = 0 ;
11947 char * kwnames[] = {
11948 (char *) "self",(char *) "y", NULL
11949 };
11950
11951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_YToEdgeOfRow",kwnames,&obj0,&obj1)) SWIG_fail;
11952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11953 if (!SWIG_IsOK(res1)) {
11954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "1"" of type '" "wxGrid *""'");
11955 }
11956 arg1 = reinterpret_cast< wxGrid * >(argp1);
11957 ecode2 = SWIG_AsVal_int(obj1, &val2);
11958 if (!SWIG_IsOK(ecode2)) {
11959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_YToEdgeOfRow" "', expected argument " "2"" of type '" "int""'");
11960 }
11961 arg2 = static_cast< int >(val2);
11962 {
11963 PyThreadState* __tstate = wxPyBeginAllowThreads();
11964 result = (int)(arg1)->YToEdgeOfRow(arg2);
11965 wxPyEndAllowThreads(__tstate);
11966 if (PyErr_Occurred()) SWIG_fail;
11967 }
11968 resultobj = SWIG_From_int(static_cast< int >(result));
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 SWIGINTERN PyObject *_wrap_Grid_XToEdgeOfCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj = 0;
11977 wxGrid *arg1 = (wxGrid *) 0 ;
11978 int arg2 ;
11979 int result;
11980 void *argp1 = 0 ;
11981 int res1 = 0 ;
11982 int val2 ;
11983 int ecode2 = 0 ;
11984 PyObject * obj0 = 0 ;
11985 PyObject * obj1 = 0 ;
11986 char * kwnames[] = {
11987 (char *) "self",(char *) "x", NULL
11988 };
11989
11990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_XToEdgeOfCol",kwnames,&obj0,&obj1)) SWIG_fail;
11991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
11992 if (!SWIG_IsOK(res1)) {
11993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "1"" of type '" "wxGrid *""'");
11994 }
11995 arg1 = reinterpret_cast< wxGrid * >(argp1);
11996 ecode2 = SWIG_AsVal_int(obj1, &val2);
11997 if (!SWIG_IsOK(ecode2)) {
11998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_XToEdgeOfCol" "', expected argument " "2"" of type '" "int""'");
11999 }
12000 arg2 = static_cast< int >(val2);
12001 {
12002 PyThreadState* __tstate = wxPyBeginAllowThreads();
12003 result = (int)(arg1)->XToEdgeOfCol(arg2);
12004 wxPyEndAllowThreads(__tstate);
12005 if (PyErr_Occurred()) SWIG_fail;
12006 }
12007 resultobj = SWIG_From_int(static_cast< int >(result));
12008 return resultobj;
12009 fail:
12010 return NULL;
12011 }
12012
12013
12014 SWIGINTERN PyObject *_wrap_Grid_CellToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12015 PyObject *resultobj = 0;
12016 wxGrid *arg1 = (wxGrid *) 0 ;
12017 int arg2 ;
12018 int arg3 ;
12019 wxRect result;
12020 void *argp1 = 0 ;
12021 int res1 = 0 ;
12022 int val2 ;
12023 int ecode2 = 0 ;
12024 int val3 ;
12025 int ecode3 = 0 ;
12026 PyObject * obj0 = 0 ;
12027 PyObject * obj1 = 0 ;
12028 PyObject * obj2 = 0 ;
12029 char * kwnames[] = {
12030 (char *) "self",(char *) "row",(char *) "col", NULL
12031 };
12032
12033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_CellToRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12035 if (!SWIG_IsOK(res1)) {
12036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CellToRect" "', expected argument " "1"" of type '" "wxGrid *""'");
12037 }
12038 arg1 = reinterpret_cast< wxGrid * >(argp1);
12039 ecode2 = SWIG_AsVal_int(obj1, &val2);
12040 if (!SWIG_IsOK(ecode2)) {
12041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_CellToRect" "', expected argument " "2"" of type '" "int""'");
12042 }
12043 arg2 = static_cast< int >(val2);
12044 ecode3 = SWIG_AsVal_int(obj2, &val3);
12045 if (!SWIG_IsOK(ecode3)) {
12046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_CellToRect" "', expected argument " "3"" of type '" "int""'");
12047 }
12048 arg3 = static_cast< int >(val3);
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = (arg1)->CellToRect(arg2,arg3);
12052 wxPyEndAllowThreads(__tstate);
12053 if (PyErr_Occurred()) SWIG_fail;
12054 }
12055 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
12056 return resultobj;
12057 fail:
12058 return NULL;
12059 }
12060
12061
12062 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12063 PyObject *resultobj = 0;
12064 wxGrid *arg1 = (wxGrid *) 0 ;
12065 int result;
12066 void *argp1 = 0 ;
12067 int res1 = 0 ;
12068 PyObject *swig_obj[1] ;
12069
12070 if (!args) SWIG_fail;
12071 swig_obj[0] = args;
12072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12073 if (!SWIG_IsOK(res1)) {
12074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorRow" "', expected argument " "1"" of type '" "wxGrid *""'");
12075 }
12076 arg1 = reinterpret_cast< wxGrid * >(argp1);
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 result = (int)(arg1)->GetGridCursorRow();
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 resultobj = SWIG_From_int(static_cast< int >(result));
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 SWIGINTERN PyObject *_wrap_Grid_GetGridCursorCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12091 PyObject *resultobj = 0;
12092 wxGrid *arg1 = (wxGrid *) 0 ;
12093 int result;
12094 void *argp1 = 0 ;
12095 int res1 = 0 ;
12096 PyObject *swig_obj[1] ;
12097
12098 if (!args) SWIG_fail;
12099 swig_obj[0] = args;
12100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12101 if (!SWIG_IsOK(res1)) {
12102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCursorCol" "', expected argument " "1"" of type '" "wxGrid *""'");
12103 }
12104 arg1 = reinterpret_cast< wxGrid * >(argp1);
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (int)(arg1)->GetGridCursorCol();
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 resultobj = SWIG_From_int(static_cast< int >(result));
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 SWIGINTERN PyObject *_wrap_Grid_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj = 0;
12120 wxGrid *arg1 = (wxGrid *) 0 ;
12121 int arg2 ;
12122 int arg3 ;
12123 bool arg4 = (bool) true ;
12124 bool result;
12125 void *argp1 = 0 ;
12126 int res1 = 0 ;
12127 int val2 ;
12128 int ecode2 = 0 ;
12129 int val3 ;
12130 int ecode3 = 0 ;
12131 bool val4 ;
12132 int ecode4 = 0 ;
12133 PyObject * obj0 = 0 ;
12134 PyObject * obj1 = 0 ;
12135 PyObject * obj2 = 0 ;
12136 PyObject * obj3 = 0 ;
12137 char * kwnames[] = {
12138 (char *) "self",(char *) "row",(char *) "col",(char *) "wholeCellVisible", NULL
12139 };
12140
12141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_IsVisible",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12143 if (!SWIG_IsOK(res1)) {
12144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12145 }
12146 arg1 = reinterpret_cast< wxGrid * >(argp1);
12147 ecode2 = SWIG_AsVal_int(obj1, &val2);
12148 if (!SWIG_IsOK(ecode2)) {
12149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsVisible" "', expected argument " "2"" of type '" "int""'");
12150 }
12151 arg2 = static_cast< int >(val2);
12152 ecode3 = SWIG_AsVal_int(obj2, &val3);
12153 if (!SWIG_IsOK(ecode3)) {
12154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsVisible" "', expected argument " "3"" of type '" "int""'");
12155 }
12156 arg3 = static_cast< int >(val3);
12157 if (obj3) {
12158 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12159 if (!SWIG_IsOK(ecode4)) {
12160 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_IsVisible" "', expected argument " "4"" of type '" "bool""'");
12161 }
12162 arg4 = static_cast< bool >(val4);
12163 }
12164 {
12165 PyThreadState* __tstate = wxPyBeginAllowThreads();
12166 result = (bool)(arg1)->IsVisible(arg2,arg3,arg4);
12167 wxPyEndAllowThreads(__tstate);
12168 if (PyErr_Occurred()) SWIG_fail;
12169 }
12170 {
12171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12172 }
12173 return resultobj;
12174 fail:
12175 return NULL;
12176 }
12177
12178
12179 SWIGINTERN PyObject *_wrap_Grid_MakeCellVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12180 PyObject *resultobj = 0;
12181 wxGrid *arg1 = (wxGrid *) 0 ;
12182 int arg2 ;
12183 int arg3 ;
12184 void *argp1 = 0 ;
12185 int res1 = 0 ;
12186 int val2 ;
12187 int ecode2 = 0 ;
12188 int val3 ;
12189 int ecode3 = 0 ;
12190 PyObject * obj0 = 0 ;
12191 PyObject * obj1 = 0 ;
12192 PyObject * obj2 = 0 ;
12193 char * kwnames[] = {
12194 (char *) "self",(char *) "row",(char *) "col", NULL
12195 };
12196
12197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_MakeCellVisible",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12199 if (!SWIG_IsOK(res1)) {
12200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MakeCellVisible" "', expected argument " "1"" of type '" "wxGrid *""'");
12201 }
12202 arg1 = reinterpret_cast< wxGrid * >(argp1);
12203 ecode2 = SWIG_AsVal_int(obj1, &val2);
12204 if (!SWIG_IsOK(ecode2)) {
12205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MakeCellVisible" "', expected argument " "2"" of type '" "int""'");
12206 }
12207 arg2 = static_cast< int >(val2);
12208 ecode3 = SWIG_AsVal_int(obj2, &val3);
12209 if (!SWIG_IsOK(ecode3)) {
12210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_MakeCellVisible" "', expected argument " "3"" of type '" "int""'");
12211 }
12212 arg3 = static_cast< int >(val3);
12213 {
12214 PyThreadState* __tstate = wxPyBeginAllowThreads();
12215 (arg1)->MakeCellVisible(arg2,arg3);
12216 wxPyEndAllowThreads(__tstate);
12217 if (PyErr_Occurred()) SWIG_fail;
12218 }
12219 resultobj = SWIG_Py_Void();
12220 return resultobj;
12221 fail:
12222 return NULL;
12223 }
12224
12225
12226 SWIGINTERN PyObject *_wrap_Grid_SetGridCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12227 PyObject *resultobj = 0;
12228 wxGrid *arg1 = (wxGrid *) 0 ;
12229 int arg2 ;
12230 int arg3 ;
12231 void *argp1 = 0 ;
12232 int res1 = 0 ;
12233 int val2 ;
12234 int ecode2 = 0 ;
12235 int val3 ;
12236 int ecode3 = 0 ;
12237 PyObject * obj0 = 0 ;
12238 PyObject * obj1 = 0 ;
12239 PyObject * obj2 = 0 ;
12240 char * kwnames[] = {
12241 (char *) "self",(char *) "row",(char *) "col", NULL
12242 };
12243
12244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetGridCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12246 if (!SWIG_IsOK(res1)) {
12247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetGridCursor" "', expected argument " "1"" of type '" "wxGrid *""'");
12248 }
12249 arg1 = reinterpret_cast< wxGrid * >(argp1);
12250 ecode2 = SWIG_AsVal_int(obj1, &val2);
12251 if (!SWIG_IsOK(ecode2)) {
12252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetGridCursor" "', expected argument " "2"" of type '" "int""'");
12253 }
12254 arg2 = static_cast< int >(val2);
12255 ecode3 = SWIG_AsVal_int(obj2, &val3);
12256 if (!SWIG_IsOK(ecode3)) {
12257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetGridCursor" "', expected argument " "3"" of type '" "int""'");
12258 }
12259 arg3 = static_cast< int >(val3);
12260 {
12261 PyThreadState* __tstate = wxPyBeginAllowThreads();
12262 (arg1)->SetGridCursor(arg2,arg3);
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 resultobj = SWIG_Py_Void();
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj = 0;
12275 wxGrid *arg1 = (wxGrid *) 0 ;
12276 bool arg2 ;
12277 bool result;
12278 void *argp1 = 0 ;
12279 int res1 = 0 ;
12280 bool val2 ;
12281 int ecode2 = 0 ;
12282 PyObject * obj0 = 0 ;
12283 PyObject * obj1 = 0 ;
12284 char * kwnames[] = {
12285 (char *) "self",(char *) "expandSelection", NULL
12286 };
12287
12288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUp",kwnames,&obj0,&obj1)) SWIG_fail;
12289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12290 if (!SWIG_IsOK(res1)) {
12291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12292 }
12293 arg1 = reinterpret_cast< wxGrid * >(argp1);
12294 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12295 if (!SWIG_IsOK(ecode2)) {
12296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUp" "', expected argument " "2"" of type '" "bool""'");
12297 }
12298 arg2 = static_cast< bool >(val2);
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 result = (bool)(arg1)->MoveCursorUp(arg2);
12302 wxPyEndAllowThreads(__tstate);
12303 if (PyErr_Occurred()) SWIG_fail;
12304 }
12305 {
12306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12307 }
12308 return resultobj;
12309 fail:
12310 return NULL;
12311 }
12312
12313
12314 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12315 PyObject *resultobj = 0;
12316 wxGrid *arg1 = (wxGrid *) 0 ;
12317 bool arg2 ;
12318 bool result;
12319 void *argp1 = 0 ;
12320 int res1 = 0 ;
12321 bool val2 ;
12322 int ecode2 = 0 ;
12323 PyObject * obj0 = 0 ;
12324 PyObject * obj1 = 0 ;
12325 char * kwnames[] = {
12326 (char *) "self",(char *) "expandSelection", NULL
12327 };
12328
12329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDown",kwnames,&obj0,&obj1)) SWIG_fail;
12330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12331 if (!SWIG_IsOK(res1)) {
12332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12333 }
12334 arg1 = reinterpret_cast< wxGrid * >(argp1);
12335 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12336 if (!SWIG_IsOK(ecode2)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDown" "', expected argument " "2"" of type '" "bool""'");
12338 }
12339 arg2 = static_cast< bool >(val2);
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 result = (bool)(arg1)->MoveCursorDown(arg2);
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 {
12347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12348 }
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj = 0;
12357 wxGrid *arg1 = (wxGrid *) 0 ;
12358 bool arg2 ;
12359 bool result;
12360 void *argp1 = 0 ;
12361 int res1 = 0 ;
12362 bool val2 ;
12363 int ecode2 = 0 ;
12364 PyObject * obj0 = 0 ;
12365 PyObject * obj1 = 0 ;
12366 char * kwnames[] = {
12367 (char *) "self",(char *) "expandSelection", NULL
12368 };
12369
12370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeft",kwnames,&obj0,&obj1)) SWIG_fail;
12371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12372 if (!SWIG_IsOK(res1)) {
12373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeft" "', expected argument " "1"" of type '" "wxGrid *""'");
12374 }
12375 arg1 = reinterpret_cast< wxGrid * >(argp1);
12376 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12377 if (!SWIG_IsOK(ecode2)) {
12378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeft" "', expected argument " "2"" of type '" "bool""'");
12379 }
12380 arg2 = static_cast< bool >(val2);
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 result = (bool)(arg1)->MoveCursorLeft(arg2);
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 {
12388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12389 }
12390 return resultobj;
12391 fail:
12392 return NULL;
12393 }
12394
12395
12396 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12397 PyObject *resultobj = 0;
12398 wxGrid *arg1 = (wxGrid *) 0 ;
12399 bool arg2 ;
12400 bool result;
12401 void *argp1 = 0 ;
12402 int res1 = 0 ;
12403 bool val2 ;
12404 int ecode2 = 0 ;
12405 PyObject * obj0 = 0 ;
12406 PyObject * obj1 = 0 ;
12407 char * kwnames[] = {
12408 (char *) "self",(char *) "expandSelection", NULL
12409 };
12410
12411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRight",kwnames,&obj0,&obj1)) SWIG_fail;
12412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12413 if (!SWIG_IsOK(res1)) {
12414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRight" "', expected argument " "1"" of type '" "wxGrid *""'");
12415 }
12416 arg1 = reinterpret_cast< wxGrid * >(argp1);
12417 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12418 if (!SWIG_IsOK(ecode2)) {
12419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRight" "', expected argument " "2"" of type '" "bool""'");
12420 }
12421 arg2 = static_cast< bool >(val2);
12422 {
12423 PyThreadState* __tstate = wxPyBeginAllowThreads();
12424 result = (bool)(arg1)->MoveCursorRight(arg2);
12425 wxPyEndAllowThreads(__tstate);
12426 if (PyErr_Occurred()) SWIG_fail;
12427 }
12428 {
12429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12430 }
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *_wrap_Grid_MovePageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12438 PyObject *resultobj = 0;
12439 wxGrid *arg1 = (wxGrid *) 0 ;
12440 bool result;
12441 void *argp1 = 0 ;
12442 int res1 = 0 ;
12443 PyObject *swig_obj[1] ;
12444
12445 if (!args) SWIG_fail;
12446 swig_obj[0] = args;
12447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12448 if (!SWIG_IsOK(res1)) {
12449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageDown" "', expected argument " "1"" of type '" "wxGrid *""'");
12450 }
12451 arg1 = reinterpret_cast< wxGrid * >(argp1);
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = (bool)(arg1)->MovePageDown();
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 {
12459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12460 }
12461 return resultobj;
12462 fail:
12463 return NULL;
12464 }
12465
12466
12467 SWIGINTERN PyObject *_wrap_Grid_MovePageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12468 PyObject *resultobj = 0;
12469 wxGrid *arg1 = (wxGrid *) 0 ;
12470 bool result;
12471 void *argp1 = 0 ;
12472 int res1 = 0 ;
12473 PyObject *swig_obj[1] ;
12474
12475 if (!args) SWIG_fail;
12476 swig_obj[0] = args;
12477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12478 if (!SWIG_IsOK(res1)) {
12479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MovePageUp" "', expected argument " "1"" of type '" "wxGrid *""'");
12480 }
12481 arg1 = reinterpret_cast< wxGrid * >(argp1);
12482 {
12483 PyThreadState* __tstate = wxPyBeginAllowThreads();
12484 result = (bool)(arg1)->MovePageUp();
12485 wxPyEndAllowThreads(__tstate);
12486 if (PyErr_Occurred()) SWIG_fail;
12487 }
12488 {
12489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12490 }
12491 return resultobj;
12492 fail:
12493 return NULL;
12494 }
12495
12496
12497 SWIGINTERN PyObject *_wrap_Grid_MoveCursorUpBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12498 PyObject *resultobj = 0;
12499 wxGrid *arg1 = (wxGrid *) 0 ;
12500 bool arg2 ;
12501 bool result;
12502 void *argp1 = 0 ;
12503 int res1 = 0 ;
12504 bool val2 ;
12505 int ecode2 = 0 ;
12506 PyObject * obj0 = 0 ;
12507 PyObject * obj1 = 0 ;
12508 char * kwnames[] = {
12509 (char *) "self",(char *) "expandSelection", NULL
12510 };
12511
12512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorUpBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12514 if (!SWIG_IsOK(res1)) {
12515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12516 }
12517 arg1 = reinterpret_cast< wxGrid * >(argp1);
12518 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12519 if (!SWIG_IsOK(ecode2)) {
12520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorUpBlock" "', expected argument " "2"" of type '" "bool""'");
12521 }
12522 arg2 = static_cast< bool >(val2);
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 result = (bool)(arg1)->MoveCursorUpBlock(arg2);
12526 wxPyEndAllowThreads(__tstate);
12527 if (PyErr_Occurred()) SWIG_fail;
12528 }
12529 {
12530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12531 }
12532 return resultobj;
12533 fail:
12534 return NULL;
12535 }
12536
12537
12538 SWIGINTERN PyObject *_wrap_Grid_MoveCursorDownBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12539 PyObject *resultobj = 0;
12540 wxGrid *arg1 = (wxGrid *) 0 ;
12541 bool arg2 ;
12542 bool result;
12543 void *argp1 = 0 ;
12544 int res1 = 0 ;
12545 bool val2 ;
12546 int ecode2 = 0 ;
12547 PyObject * obj0 = 0 ;
12548 PyObject * obj1 = 0 ;
12549 char * kwnames[] = {
12550 (char *) "self",(char *) "expandSelection", NULL
12551 };
12552
12553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorDownBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12555 if (!SWIG_IsOK(res1)) {
12556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12557 }
12558 arg1 = reinterpret_cast< wxGrid * >(argp1);
12559 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12560 if (!SWIG_IsOK(ecode2)) {
12561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorDownBlock" "', expected argument " "2"" of type '" "bool""'");
12562 }
12563 arg2 = static_cast< bool >(val2);
12564 {
12565 PyThreadState* __tstate = wxPyBeginAllowThreads();
12566 result = (bool)(arg1)->MoveCursorDownBlock(arg2);
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 {
12571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12572 }
12573 return resultobj;
12574 fail:
12575 return NULL;
12576 }
12577
12578
12579 SWIGINTERN PyObject *_wrap_Grid_MoveCursorLeftBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj = 0;
12581 wxGrid *arg1 = (wxGrid *) 0 ;
12582 bool arg2 ;
12583 bool result;
12584 void *argp1 = 0 ;
12585 int res1 = 0 ;
12586 bool val2 ;
12587 int ecode2 = 0 ;
12588 PyObject * obj0 = 0 ;
12589 PyObject * obj1 = 0 ;
12590 char * kwnames[] = {
12591 (char *) "self",(char *) "expandSelection", NULL
12592 };
12593
12594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorLeftBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12596 if (!SWIG_IsOK(res1)) {
12597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12598 }
12599 arg1 = reinterpret_cast< wxGrid * >(argp1);
12600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12601 if (!SWIG_IsOK(ecode2)) {
12602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorLeftBlock" "', expected argument " "2"" of type '" "bool""'");
12603 }
12604 arg2 = static_cast< bool >(val2);
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 result = (bool)(arg1)->MoveCursorLeftBlock(arg2);
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 {
12612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12613 }
12614 return resultobj;
12615 fail:
12616 return NULL;
12617 }
12618
12619
12620 SWIGINTERN PyObject *_wrap_Grid_MoveCursorRightBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12621 PyObject *resultobj = 0;
12622 wxGrid *arg1 = (wxGrid *) 0 ;
12623 bool arg2 ;
12624 bool result;
12625 void *argp1 = 0 ;
12626 int res1 = 0 ;
12627 bool val2 ;
12628 int ecode2 = 0 ;
12629 PyObject * obj0 = 0 ;
12630 PyObject * obj1 = 0 ;
12631 char * kwnames[] = {
12632 (char *) "self",(char *) "expandSelection", NULL
12633 };
12634
12635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_MoveCursorRightBlock",kwnames,&obj0,&obj1)) SWIG_fail;
12636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12637 if (!SWIG_IsOK(res1)) {
12638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
12639 }
12640 arg1 = reinterpret_cast< wxGrid * >(argp1);
12641 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12642 if (!SWIG_IsOK(ecode2)) {
12643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_MoveCursorRightBlock" "', expected argument " "2"" of type '" "bool""'");
12644 }
12645 arg2 = static_cast< bool >(val2);
12646 {
12647 PyThreadState* __tstate = wxPyBeginAllowThreads();
12648 result = (bool)(arg1)->MoveCursorRightBlock(arg2);
12649 wxPyEndAllowThreads(__tstate);
12650 if (PyErr_Occurred()) SWIG_fail;
12651 }
12652 {
12653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12654 }
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12662 PyObject *resultobj = 0;
12663 wxGrid *arg1 = (wxGrid *) 0 ;
12664 int result;
12665 void *argp1 = 0 ;
12666 int res1 = 0 ;
12667 PyObject *swig_obj[1] ;
12668
12669 if (!args) SWIG_fail;
12670 swig_obj[0] = args;
12671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12672 if (!SWIG_IsOK(res1)) {
12673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12674 }
12675 arg1 = reinterpret_cast< wxGrid * >(argp1);
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 result = (int)(arg1)->GetDefaultRowLabelSize();
12679 wxPyEndAllowThreads(__tstate);
12680 if (PyErr_Occurred()) SWIG_fail;
12681 }
12682 resultobj = SWIG_From_int(static_cast< int >(result));
12683 return resultobj;
12684 fail:
12685 return NULL;
12686 }
12687
12688
12689 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12690 PyObject *resultobj = 0;
12691 wxGrid *arg1 = (wxGrid *) 0 ;
12692 int result;
12693 void *argp1 = 0 ;
12694 int res1 = 0 ;
12695 PyObject *swig_obj[1] ;
12696
12697 if (!args) SWIG_fail;
12698 swig_obj[0] = args;
12699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12700 if (!SWIG_IsOK(res1)) {
12701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12702 }
12703 arg1 = reinterpret_cast< wxGrid * >(argp1);
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 result = (int)(arg1)->GetRowLabelSize();
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 resultobj = SWIG_From_int(static_cast< int >(result));
12711 return resultobj;
12712 fail:
12713 return NULL;
12714 }
12715
12716
12717 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12718 PyObject *resultobj = 0;
12719 wxGrid *arg1 = (wxGrid *) 0 ;
12720 int result;
12721 void *argp1 = 0 ;
12722 int res1 = 0 ;
12723 PyObject *swig_obj[1] ;
12724
12725 if (!args) SWIG_fail;
12726 swig_obj[0] = args;
12727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12728 if (!SWIG_IsOK(res1)) {
12729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12730 }
12731 arg1 = reinterpret_cast< wxGrid * >(argp1);
12732 {
12733 PyThreadState* __tstate = wxPyBeginAllowThreads();
12734 result = (int)(arg1)->GetDefaultColLabelSize();
12735 wxPyEndAllowThreads(__tstate);
12736 if (PyErr_Occurred()) SWIG_fail;
12737 }
12738 resultobj = SWIG_From_int(static_cast< int >(result));
12739 return resultobj;
12740 fail:
12741 return NULL;
12742 }
12743
12744
12745 SWIGINTERN PyObject *_wrap_Grid_GetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12746 PyObject *resultobj = 0;
12747 wxGrid *arg1 = (wxGrid *) 0 ;
12748 int result;
12749 void *argp1 = 0 ;
12750 int res1 = 0 ;
12751 PyObject *swig_obj[1] ;
12752
12753 if (!args) SWIG_fail;
12754 swig_obj[0] = args;
12755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12756 if (!SWIG_IsOK(res1)) {
12757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
12758 }
12759 arg1 = reinterpret_cast< wxGrid * >(argp1);
12760 {
12761 PyThreadState* __tstate = wxPyBeginAllowThreads();
12762 result = (int)(arg1)->GetColLabelSize();
12763 wxPyEndAllowThreads(__tstate);
12764 if (PyErr_Occurred()) SWIG_fail;
12765 }
12766 resultobj = SWIG_From_int(static_cast< int >(result));
12767 return resultobj;
12768 fail:
12769 return NULL;
12770 }
12771
12772
12773 SWIGINTERN PyObject *_wrap_Grid_GetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12774 PyObject *resultobj = 0;
12775 wxGrid *arg1 = (wxGrid *) 0 ;
12776 wxColour result;
12777 void *argp1 = 0 ;
12778 int res1 = 0 ;
12779 PyObject *swig_obj[1] ;
12780
12781 if (!args) SWIG_fail;
12782 swig_obj[0] = args;
12783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12784 if (!SWIG_IsOK(res1)) {
12785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12786 }
12787 arg1 = reinterpret_cast< wxGrid * >(argp1);
12788 {
12789 PyThreadState* __tstate = wxPyBeginAllowThreads();
12790 result = (arg1)->GetLabelBackgroundColour();
12791 wxPyEndAllowThreads(__tstate);
12792 if (PyErr_Occurred()) SWIG_fail;
12793 }
12794 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12795 return resultobj;
12796 fail:
12797 return NULL;
12798 }
12799
12800
12801 SWIGINTERN PyObject *_wrap_Grid_GetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12802 PyObject *resultobj = 0;
12803 wxGrid *arg1 = (wxGrid *) 0 ;
12804 wxColour result;
12805 void *argp1 = 0 ;
12806 int res1 = 0 ;
12807 PyObject *swig_obj[1] ;
12808
12809 if (!args) SWIG_fail;
12810 swig_obj[0] = args;
12811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12812 if (!SWIG_IsOK(res1)) {
12813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
12814 }
12815 arg1 = reinterpret_cast< wxGrid * >(argp1);
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 result = (arg1)->GetLabelTextColour();
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
12823 return resultobj;
12824 fail:
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *_wrap_Grid_GetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12830 PyObject *resultobj = 0;
12831 wxGrid *arg1 = (wxGrid *) 0 ;
12832 wxFont result;
12833 void *argp1 = 0 ;
12834 int res1 = 0 ;
12835 PyObject *swig_obj[1] ;
12836
12837 if (!args) SWIG_fail;
12838 swig_obj[0] = args;
12839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12840 if (!SWIG_IsOK(res1)) {
12841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
12842 }
12843 arg1 = reinterpret_cast< wxGrid * >(argp1);
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = (arg1)->GetLabelFont();
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
12851 return resultobj;
12852 fail:
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12858 PyObject *resultobj = 0;
12859 wxGrid *arg1 = (wxGrid *) 0 ;
12860 int *arg2 = (int *) 0 ;
12861 int *arg3 = (int *) 0 ;
12862 void *argp1 = 0 ;
12863 int res1 = 0 ;
12864 int temp2 ;
12865 int res2 = SWIG_TMPOBJ ;
12866 int temp3 ;
12867 int res3 = SWIG_TMPOBJ ;
12868 PyObject *swig_obj[1] ;
12869
12870 arg2 = &temp2;
12871 arg3 = &temp3;
12872 if (!args) SWIG_fail;
12873 swig_obj[0] = args;
12874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12875 if (!SWIG_IsOK(res1)) {
12876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12877 }
12878 arg1 = reinterpret_cast< wxGrid * >(argp1);
12879 {
12880 PyThreadState* __tstate = wxPyBeginAllowThreads();
12881 (arg1)->GetRowLabelAlignment(arg2,arg3);
12882 wxPyEndAllowThreads(__tstate);
12883 if (PyErr_Occurred()) SWIG_fail;
12884 }
12885 resultobj = SWIG_Py_Void();
12886 if (SWIG_IsTmpObj(res2)) {
12887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12888 } else {
12889 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12891 }
12892 if (SWIG_IsTmpObj(res3)) {
12893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12894 } else {
12895 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12897 }
12898 return resultobj;
12899 fail:
12900 return NULL;
12901 }
12902
12903
12904 SWIGINTERN PyObject *_wrap_Grid_GetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12905 PyObject *resultobj = 0;
12906 wxGrid *arg1 = (wxGrid *) 0 ;
12907 int *arg2 = (int *) 0 ;
12908 int *arg3 = (int *) 0 ;
12909 void *argp1 = 0 ;
12910 int res1 = 0 ;
12911 int temp2 ;
12912 int res2 = SWIG_TMPOBJ ;
12913 int temp3 ;
12914 int res3 = SWIG_TMPOBJ ;
12915 PyObject *swig_obj[1] ;
12916
12917 arg2 = &temp2;
12918 arg3 = &temp3;
12919 if (!args) SWIG_fail;
12920 swig_obj[0] = args;
12921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12922 if (!SWIG_IsOK(res1)) {
12923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
12924 }
12925 arg1 = reinterpret_cast< wxGrid * >(argp1);
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 (arg1)->GetColLabelAlignment(arg2,arg3);
12929 wxPyEndAllowThreads(__tstate);
12930 if (PyErr_Occurred()) SWIG_fail;
12931 }
12932 resultobj = SWIG_Py_Void();
12933 if (SWIG_IsTmpObj(res2)) {
12934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
12935 } else {
12936 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
12938 }
12939 if (SWIG_IsTmpObj(res3)) {
12940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
12941 } else {
12942 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
12944 }
12945 return resultobj;
12946 fail:
12947 return NULL;
12948 }
12949
12950
12951 SWIGINTERN PyObject *_wrap_Grid_GetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12952 PyObject *resultobj = 0;
12953 wxGrid *arg1 = (wxGrid *) 0 ;
12954 int result;
12955 void *argp1 = 0 ;
12956 int res1 = 0 ;
12957 PyObject *swig_obj[1] ;
12958
12959 if (!args) SWIG_fail;
12960 swig_obj[0] = args;
12961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12962 if (!SWIG_IsOK(res1)) {
12963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
12964 }
12965 arg1 = reinterpret_cast< wxGrid * >(argp1);
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 result = (int)(arg1)->GetColLabelTextOrientation();
12969 wxPyEndAllowThreads(__tstate);
12970 if (PyErr_Occurred()) SWIG_fail;
12971 }
12972 resultobj = SWIG_From_int(static_cast< int >(result));
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 SWIGINTERN PyObject *_wrap_Grid_GetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj = 0;
12981 wxGrid *arg1 = (wxGrid *) 0 ;
12982 int arg2 ;
12983 wxString result;
12984 void *argp1 = 0 ;
12985 int res1 = 0 ;
12986 int val2 ;
12987 int ecode2 = 0 ;
12988 PyObject * obj0 = 0 ;
12989 PyObject * obj1 = 0 ;
12990 char * kwnames[] = {
12991 (char *) "self",(char *) "row", NULL
12992 };
12993
12994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
12995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
12996 if (!SWIG_IsOK(res1)) {
12997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
12998 }
12999 arg1 = reinterpret_cast< wxGrid * >(argp1);
13000 ecode2 = SWIG_AsVal_int(obj1, &val2);
13001 if (!SWIG_IsOK(ecode2)) {
13002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13003 }
13004 arg2 = static_cast< int >(val2);
13005 {
13006 PyThreadState* __tstate = wxPyBeginAllowThreads();
13007 result = (arg1)->GetRowLabelValue(arg2);
13008 wxPyEndAllowThreads(__tstate);
13009 if (PyErr_Occurred()) SWIG_fail;
13010 }
13011 {
13012 #if wxUSE_UNICODE
13013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13014 #else
13015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13016 #endif
13017 }
13018 return resultobj;
13019 fail:
13020 return NULL;
13021 }
13022
13023
13024 SWIGINTERN PyObject *_wrap_Grid_GetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13025 PyObject *resultobj = 0;
13026 wxGrid *arg1 = (wxGrid *) 0 ;
13027 int arg2 ;
13028 wxString result;
13029 void *argp1 = 0 ;
13030 int res1 = 0 ;
13031 int val2 ;
13032 int ecode2 = 0 ;
13033 PyObject * obj0 = 0 ;
13034 PyObject * obj1 = 0 ;
13035 char * kwnames[] = {
13036 (char *) "self",(char *) "col", NULL
13037 };
13038
13039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColLabelValue",kwnames,&obj0,&obj1)) SWIG_fail;
13040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13041 if (!SWIG_IsOK(res1)) {
13042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13043 }
13044 arg1 = reinterpret_cast< wxGrid * >(argp1);
13045 ecode2 = SWIG_AsVal_int(obj1, &val2);
13046 if (!SWIG_IsOK(ecode2)) {
13047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13048 }
13049 arg2 = static_cast< int >(val2);
13050 {
13051 PyThreadState* __tstate = wxPyBeginAllowThreads();
13052 result = (arg1)->GetColLabelValue(arg2);
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 {
13057 #if wxUSE_UNICODE
13058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13059 #else
13060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13061 #endif
13062 }
13063 return resultobj;
13064 fail:
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *_wrap_Grid_GetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13070 PyObject *resultobj = 0;
13071 wxGrid *arg1 = (wxGrid *) 0 ;
13072 wxColour result;
13073 void *argp1 = 0 ;
13074 int res1 = 0 ;
13075 PyObject *swig_obj[1] ;
13076
13077 if (!args) SWIG_fail;
13078 swig_obj[0] = args;
13079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13080 if (!SWIG_IsOK(res1)) {
13081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13082 }
13083 arg1 = reinterpret_cast< wxGrid * >(argp1);
13084 {
13085 PyThreadState* __tstate = wxPyBeginAllowThreads();
13086 result = (arg1)->GetGridLineColour();
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13091 return resultobj;
13092 fail:
13093 return NULL;
13094 }
13095
13096
13097 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13098 PyObject *resultobj = 0;
13099 wxGrid *arg1 = (wxGrid *) 0 ;
13100 wxColour result;
13101 void *argp1 = 0 ;
13102 int res1 = 0 ;
13103 PyObject *swig_obj[1] ;
13104
13105 if (!args) SWIG_fail;
13106 swig_obj[0] = args;
13107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13108 if (!SWIG_IsOK(res1)) {
13109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13110 }
13111 arg1 = reinterpret_cast< wxGrid * >(argp1);
13112 {
13113 PyThreadState* __tstate = wxPyBeginAllowThreads();
13114 result = (arg1)->GetCellHighlightColour();
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
13119 return resultobj;
13120 fail:
13121 return NULL;
13122 }
13123
13124
13125 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13126 PyObject *resultobj = 0;
13127 wxGrid *arg1 = (wxGrid *) 0 ;
13128 int result;
13129 void *argp1 = 0 ;
13130 int res1 = 0 ;
13131 PyObject *swig_obj[1] ;
13132
13133 if (!args) SWIG_fail;
13134 swig_obj[0] = args;
13135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13136 if (!SWIG_IsOK(res1)) {
13137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13138 }
13139 arg1 = reinterpret_cast< wxGrid * >(argp1);
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 result = (int)(arg1)->GetCellHighlightPenWidth();
13143 wxPyEndAllowThreads(__tstate);
13144 if (PyErr_Occurred()) SWIG_fail;
13145 }
13146 resultobj = SWIG_From_int(static_cast< int >(result));
13147 return resultobj;
13148 fail:
13149 return NULL;
13150 }
13151
13152
13153 SWIGINTERN PyObject *_wrap_Grid_GetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13154 PyObject *resultobj = 0;
13155 wxGrid *arg1 = (wxGrid *) 0 ;
13156 int result;
13157 void *argp1 = 0 ;
13158 int res1 = 0 ;
13159 PyObject *swig_obj[1] ;
13160
13161 if (!args) SWIG_fail;
13162 swig_obj[0] = args;
13163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13164 if (!SWIG_IsOK(res1)) {
13165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13166 }
13167 arg1 = reinterpret_cast< wxGrid * >(argp1);
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 result = (int)(arg1)->GetCellHighlightROPenWidth();
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 resultobj = SWIG_From_int(static_cast< int >(result));
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13182 PyObject *resultobj = 0;
13183 wxGrid *arg1 = (wxGrid *) 0 ;
13184 int arg2 ;
13185 void *argp1 = 0 ;
13186 int res1 = 0 ;
13187 int val2 ;
13188 int ecode2 = 0 ;
13189 PyObject * obj0 = 0 ;
13190 PyObject * obj1 = 0 ;
13191 char * kwnames[] = {
13192 (char *) "self",(char *) "width", NULL
13193 };
13194
13195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13197 if (!SWIG_IsOK(res1)) {
13198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13199 }
13200 arg1 = reinterpret_cast< wxGrid * >(argp1);
13201 ecode2 = SWIG_AsVal_int(obj1, &val2);
13202 if (!SWIG_IsOK(ecode2)) {
13203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelSize" "', expected argument " "2"" of type '" "int""'");
13204 }
13205 arg2 = static_cast< int >(val2);
13206 {
13207 PyThreadState* __tstate = wxPyBeginAllowThreads();
13208 (arg1)->SetRowLabelSize(arg2);
13209 wxPyEndAllowThreads(__tstate);
13210 if (PyErr_Occurred()) SWIG_fail;
13211 }
13212 resultobj = SWIG_Py_Void();
13213 return resultobj;
13214 fail:
13215 return NULL;
13216 }
13217
13218
13219 SWIGINTERN PyObject *_wrap_Grid_SetColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13220 PyObject *resultobj = 0;
13221 wxGrid *arg1 = (wxGrid *) 0 ;
13222 int arg2 ;
13223 void *argp1 = 0 ;
13224 int res1 = 0 ;
13225 int val2 ;
13226 int ecode2 = 0 ;
13227 PyObject * obj0 = 0 ;
13228 PyObject * obj1 = 0 ;
13229 char * kwnames[] = {
13230 (char *) "self",(char *) "height", NULL
13231 };
13232
13233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
13234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13235 if (!SWIG_IsOK(res1)) {
13236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13237 }
13238 arg1 = reinterpret_cast< wxGrid * >(argp1);
13239 ecode2 = SWIG_AsVal_int(obj1, &val2);
13240 if (!SWIG_IsOK(ecode2)) {
13241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelSize" "', expected argument " "2"" of type '" "int""'");
13242 }
13243 arg2 = static_cast< int >(val2);
13244 {
13245 PyThreadState* __tstate = wxPyBeginAllowThreads();
13246 (arg1)->SetColLabelSize(arg2);
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 resultobj = SWIG_Py_Void();
13251 return resultobj;
13252 fail:
13253 return NULL;
13254 }
13255
13256
13257 SWIGINTERN PyObject *_wrap_Grid_SetLabelBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj = 0;
13259 wxGrid *arg1 = (wxGrid *) 0 ;
13260 wxColour *arg2 = 0 ;
13261 void *argp1 = 0 ;
13262 int res1 = 0 ;
13263 wxColour temp2 ;
13264 PyObject * obj0 = 0 ;
13265 PyObject * obj1 = 0 ;
13266 char * kwnames[] = {
13267 (char *) "self",(char *)"arg2", NULL
13268 };
13269
13270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
13271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13272 if (!SWIG_IsOK(res1)) {
13273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13274 }
13275 arg1 = reinterpret_cast< wxGrid * >(argp1);
13276 {
13277 arg2 = &temp2;
13278 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13279 }
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 (arg1)->SetLabelBackgroundColour((wxColour const &)*arg2);
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 resultobj = SWIG_Py_Void();
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_Grid_SetLabelTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj = 0;
13295 wxGrid *arg1 = (wxGrid *) 0 ;
13296 wxColour *arg2 = 0 ;
13297 void *argp1 = 0 ;
13298 int res1 = 0 ;
13299 wxColour temp2 ;
13300 PyObject * obj0 = 0 ;
13301 PyObject * obj1 = 0 ;
13302 char * kwnames[] = {
13303 (char *) "self",(char *)"arg2", NULL
13304 };
13305
13306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
13307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13308 if (!SWIG_IsOK(res1)) {
13309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13310 }
13311 arg1 = reinterpret_cast< wxGrid * >(argp1);
13312 {
13313 arg2 = &temp2;
13314 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13315 }
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 (arg1)->SetLabelTextColour((wxColour const &)*arg2);
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 resultobj = SWIG_Py_Void();
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 SWIGINTERN PyObject *_wrap_Grid_SetLabelFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj = 0;
13331 wxGrid *arg1 = (wxGrid *) 0 ;
13332 wxFont *arg2 = 0 ;
13333 void *argp1 = 0 ;
13334 int res1 = 0 ;
13335 void *argp2 = 0 ;
13336 int res2 = 0 ;
13337 PyObject * obj0 = 0 ;
13338 PyObject * obj1 = 0 ;
13339 char * kwnames[] = {
13340 (char *) "self",(char *)"arg2", NULL
13341 };
13342
13343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetLabelFont",kwnames,&obj0,&obj1)) SWIG_fail;
13344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13345 if (!SWIG_IsOK(res1)) {
13346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetLabelFont" "', expected argument " "1"" of type '" "wxGrid *""'");
13347 }
13348 arg1 = reinterpret_cast< wxGrid * >(argp1);
13349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
13350 if (!SWIG_IsOK(res2)) {
13351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13352 }
13353 if (!argp2) {
13354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetLabelFont" "', expected argument " "2"" of type '" "wxFont const &""'");
13355 }
13356 arg2 = reinterpret_cast< wxFont * >(argp2);
13357 {
13358 PyThreadState* __tstate = wxPyBeginAllowThreads();
13359 (arg1)->SetLabelFont((wxFont const &)*arg2);
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 resultobj = SWIG_Py_Void();
13364 return resultobj;
13365 fail:
13366 return NULL;
13367 }
13368
13369
13370 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13371 PyObject *resultobj = 0;
13372 wxGrid *arg1 = (wxGrid *) 0 ;
13373 int arg2 ;
13374 int arg3 ;
13375 void *argp1 = 0 ;
13376 int res1 = 0 ;
13377 int val2 ;
13378 int ecode2 = 0 ;
13379 int val3 ;
13380 int ecode3 = 0 ;
13381 PyObject * obj0 = 0 ;
13382 PyObject * obj1 = 0 ;
13383 PyObject * obj2 = 0 ;
13384 char * kwnames[] = {
13385 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13386 };
13387
13388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13390 if (!SWIG_IsOK(res1)) {
13391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13392 }
13393 arg1 = reinterpret_cast< wxGrid * >(argp1);
13394 ecode2 = SWIG_AsVal_int(obj1, &val2);
13395 if (!SWIG_IsOK(ecode2)) {
13396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13397 }
13398 arg2 = static_cast< int >(val2);
13399 ecode3 = SWIG_AsVal_int(obj2, &val3);
13400 if (!SWIG_IsOK(ecode3)) {
13401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13402 }
13403 arg3 = static_cast< int >(val3);
13404 {
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 (arg1)->SetRowLabelAlignment(arg2,arg3);
13407 wxPyEndAllowThreads(__tstate);
13408 if (PyErr_Occurred()) SWIG_fail;
13409 }
13410 resultobj = SWIG_Py_Void();
13411 return resultobj;
13412 fail:
13413 return NULL;
13414 }
13415
13416
13417 SWIGINTERN PyObject *_wrap_Grid_SetColLabelAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj = 0;
13419 wxGrid *arg1 = (wxGrid *) 0 ;
13420 int arg2 ;
13421 int arg3 ;
13422 void *argp1 = 0 ;
13423 int res1 = 0 ;
13424 int val2 ;
13425 int ecode2 = 0 ;
13426 int val3 ;
13427 int ecode3 = 0 ;
13428 PyObject * obj0 = 0 ;
13429 PyObject * obj1 = 0 ;
13430 PyObject * obj2 = 0 ;
13431 char * kwnames[] = {
13432 (char *) "self",(char *) "horiz",(char *) "vert", NULL
13433 };
13434
13435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13437 if (!SWIG_IsOK(res1)) {
13438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
13439 }
13440 arg1 = reinterpret_cast< wxGrid * >(argp1);
13441 ecode2 = SWIG_AsVal_int(obj1, &val2);
13442 if (!SWIG_IsOK(ecode2)) {
13443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "2"" of type '" "int""'");
13444 }
13445 arg2 = static_cast< int >(val2);
13446 ecode3 = SWIG_AsVal_int(obj2, &val3);
13447 if (!SWIG_IsOK(ecode3)) {
13448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColLabelAlignment" "', expected argument " "3"" of type '" "int""'");
13449 }
13450 arg3 = static_cast< int >(val3);
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 (arg1)->SetColLabelAlignment(arg2,arg3);
13454 wxPyEndAllowThreads(__tstate);
13455 if (PyErr_Occurred()) SWIG_fail;
13456 }
13457 resultobj = SWIG_Py_Void();
13458 return resultobj;
13459 fail:
13460 return NULL;
13461 }
13462
13463
13464 SWIGINTERN PyObject *_wrap_Grid_SetColLabelTextOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13465 PyObject *resultobj = 0;
13466 wxGrid *arg1 = (wxGrid *) 0 ;
13467 int arg2 ;
13468 void *argp1 = 0 ;
13469 int res1 = 0 ;
13470 int val2 ;
13471 int ecode2 = 0 ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 char * kwnames[] = {
13475 (char *) "self",(char *) "textOrientation", NULL
13476 };
13477
13478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColLabelTextOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
13479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13480 if (!SWIG_IsOK(res1)) {
13481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "1"" of type '" "wxGrid *""'");
13482 }
13483 arg1 = reinterpret_cast< wxGrid * >(argp1);
13484 ecode2 = SWIG_AsVal_int(obj1, &val2);
13485 if (!SWIG_IsOK(ecode2)) {
13486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelTextOrientation" "', expected argument " "2"" of type '" "int""'");
13487 }
13488 arg2 = static_cast< int >(val2);
13489 {
13490 PyThreadState* __tstate = wxPyBeginAllowThreads();
13491 (arg1)->SetColLabelTextOrientation(arg2);
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 resultobj = SWIG_Py_Void();
13496 return resultobj;
13497 fail:
13498 return NULL;
13499 }
13500
13501
13502 SWIGINTERN PyObject *_wrap_Grid_SetRowLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13503 PyObject *resultobj = 0;
13504 wxGrid *arg1 = (wxGrid *) 0 ;
13505 int arg2 ;
13506 wxString *arg3 = 0 ;
13507 void *argp1 = 0 ;
13508 int res1 = 0 ;
13509 int val2 ;
13510 int ecode2 = 0 ;
13511 bool temp3 = false ;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 PyObject * obj2 = 0 ;
13515 char * kwnames[] = {
13516 (char *) "self",(char *) "row",(char *)"arg3", NULL
13517 };
13518
13519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13521 if (!SWIG_IsOK(res1)) {
13522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13523 }
13524 arg1 = reinterpret_cast< wxGrid * >(argp1);
13525 ecode2 = SWIG_AsVal_int(obj1, &val2);
13526 if (!SWIG_IsOK(ecode2)) {
13527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowLabelValue" "', expected argument " "2"" of type '" "int""'");
13528 }
13529 arg2 = static_cast< int >(val2);
13530 {
13531 arg3 = wxString_in_helper(obj2);
13532 if (arg3 == NULL) SWIG_fail;
13533 temp3 = true;
13534 }
13535 {
13536 PyThreadState* __tstate = wxPyBeginAllowThreads();
13537 (arg1)->SetRowLabelValue(arg2,(wxString const &)*arg3);
13538 wxPyEndAllowThreads(__tstate);
13539 if (PyErr_Occurred()) SWIG_fail;
13540 }
13541 resultobj = SWIG_Py_Void();
13542 {
13543 if (temp3)
13544 delete arg3;
13545 }
13546 return resultobj;
13547 fail:
13548 {
13549 if (temp3)
13550 delete arg3;
13551 }
13552 return NULL;
13553 }
13554
13555
13556 SWIGINTERN PyObject *_wrap_Grid_SetColLabelValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13557 PyObject *resultobj = 0;
13558 wxGrid *arg1 = (wxGrid *) 0 ;
13559 int arg2 ;
13560 wxString *arg3 = 0 ;
13561 void *argp1 = 0 ;
13562 int res1 = 0 ;
13563 int val2 ;
13564 int ecode2 = 0 ;
13565 bool temp3 = false ;
13566 PyObject * obj0 = 0 ;
13567 PyObject * obj1 = 0 ;
13568 PyObject * obj2 = 0 ;
13569 char * kwnames[] = {
13570 (char *) "self",(char *) "col",(char *)"arg3", NULL
13571 };
13572
13573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColLabelValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13575 if (!SWIG_IsOK(res1)) {
13576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColLabelValue" "', expected argument " "1"" of type '" "wxGrid *""'");
13577 }
13578 arg1 = reinterpret_cast< wxGrid * >(argp1);
13579 ecode2 = SWIG_AsVal_int(obj1, &val2);
13580 if (!SWIG_IsOK(ecode2)) {
13581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColLabelValue" "', expected argument " "2"" of type '" "int""'");
13582 }
13583 arg2 = static_cast< int >(val2);
13584 {
13585 arg3 = wxString_in_helper(obj2);
13586 if (arg3 == NULL) SWIG_fail;
13587 temp3 = true;
13588 }
13589 {
13590 PyThreadState* __tstate = wxPyBeginAllowThreads();
13591 (arg1)->SetColLabelValue(arg2,(wxString const &)*arg3);
13592 wxPyEndAllowThreads(__tstate);
13593 if (PyErr_Occurred()) SWIG_fail;
13594 }
13595 resultobj = SWIG_Py_Void();
13596 {
13597 if (temp3)
13598 delete arg3;
13599 }
13600 return resultobj;
13601 fail:
13602 {
13603 if (temp3)
13604 delete arg3;
13605 }
13606 return NULL;
13607 }
13608
13609
13610 SWIGINTERN PyObject *_wrap_Grid_SetGridLineColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13611 PyObject *resultobj = 0;
13612 wxGrid *arg1 = (wxGrid *) 0 ;
13613 wxColour *arg2 = 0 ;
13614 void *argp1 = 0 ;
13615 int res1 = 0 ;
13616 wxColour temp2 ;
13617 PyObject * obj0 = 0 ;
13618 PyObject * obj1 = 0 ;
13619 char * kwnames[] = {
13620 (char *) "self",(char *)"arg2", NULL
13621 };
13622
13623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetGridLineColour",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_SetGridLineColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13627 }
13628 arg1 = reinterpret_cast< wxGrid * >(argp1);
13629 {
13630 arg2 = &temp2;
13631 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13632 }
13633 {
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 (arg1)->SetGridLineColour((wxColour const &)*arg2);
13636 wxPyEndAllowThreads(__tstate);
13637 if (PyErr_Occurred()) SWIG_fail;
13638 }
13639 resultobj = SWIG_Py_Void();
13640 return resultobj;
13641 fail:
13642 return NULL;
13643 }
13644
13645
13646 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13647 PyObject *resultobj = 0;
13648 wxGrid *arg1 = (wxGrid *) 0 ;
13649 wxColour *arg2 = 0 ;
13650 void *argp1 = 0 ;
13651 int res1 = 0 ;
13652 wxColour temp2 ;
13653 PyObject * obj0 = 0 ;
13654 PyObject * obj1 = 0 ;
13655 char * kwnames[] = {
13656 (char *) "self",(char *)"arg2", NULL
13657 };
13658
13659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightColour",kwnames,&obj0,&obj1)) SWIG_fail;
13660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13661 if (!SWIG_IsOK(res1)) {
13662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightColour" "', expected argument " "1"" of type '" "wxGrid *""'");
13663 }
13664 arg1 = reinterpret_cast< wxGrid * >(argp1);
13665 {
13666 arg2 = &temp2;
13667 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
13668 }
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 (arg1)->SetCellHighlightColour((wxColour const &)*arg2);
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_Py_Void();
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj = 0;
13684 wxGrid *arg1 = (wxGrid *) 0 ;
13685 int arg2 ;
13686 void *argp1 = 0 ;
13687 int res1 = 0 ;
13688 int val2 ;
13689 int ecode2 = 0 ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 char * kwnames[] = {
13693 (char *) "self",(char *) "width", NULL
13694 };
13695
13696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightPenWidth",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_SetCellHighlightPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13700 }
13701 arg1 = reinterpret_cast< wxGrid * >(argp1);
13702 ecode2 = SWIG_AsVal_int(obj1, &val2);
13703 if (!SWIG_IsOK(ecode2)) {
13704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightPenWidth" "', expected argument " "2"" of type '" "int""'");
13705 }
13706 arg2 = static_cast< int >(val2);
13707 {
13708 PyThreadState* __tstate = wxPyBeginAllowThreads();
13709 (arg1)->SetCellHighlightPenWidth(arg2);
13710 wxPyEndAllowThreads(__tstate);
13711 if (PyErr_Occurred()) SWIG_fail;
13712 }
13713 resultobj = SWIG_Py_Void();
13714 return resultobj;
13715 fail:
13716 return NULL;
13717 }
13718
13719
13720 SWIGINTERN PyObject *_wrap_Grid_SetCellHighlightROPenWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13721 PyObject *resultobj = 0;
13722 wxGrid *arg1 = (wxGrid *) 0 ;
13723 int arg2 ;
13724 void *argp1 = 0 ;
13725 int res1 = 0 ;
13726 int val2 ;
13727 int ecode2 = 0 ;
13728 PyObject * obj0 = 0 ;
13729 PyObject * obj1 = 0 ;
13730 char * kwnames[] = {
13731 (char *) "self",(char *) "width", NULL
13732 };
13733
13734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetCellHighlightROPenWidth",kwnames,&obj0,&obj1)) SWIG_fail;
13735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13736 if (!SWIG_IsOK(res1)) {
13737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
13738 }
13739 arg1 = reinterpret_cast< wxGrid * >(argp1);
13740 ecode2 = SWIG_AsVal_int(obj1, &val2);
13741 if (!SWIG_IsOK(ecode2)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellHighlightROPenWidth" "', expected argument " "2"" of type '" "int""'");
13743 }
13744 arg2 = static_cast< int >(val2);
13745 {
13746 PyThreadState* __tstate = wxPyBeginAllowThreads();
13747 (arg1)->SetCellHighlightROPenWidth(arg2);
13748 wxPyEndAllowThreads(__tstate);
13749 if (PyErr_Occurred()) SWIG_fail;
13750 }
13751 resultobj = SWIG_Py_Void();
13752 return resultobj;
13753 fail:
13754 return NULL;
13755 }
13756
13757
13758 SWIGINTERN PyObject *_wrap_Grid_EnableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13759 PyObject *resultobj = 0;
13760 wxGrid *arg1 = (wxGrid *) 0 ;
13761 bool arg2 = (bool) true ;
13762 void *argp1 = 0 ;
13763 int res1 = 0 ;
13764 bool val2 ;
13765 int ecode2 = 0 ;
13766 PyObject * obj0 = 0 ;
13767 PyObject * obj1 = 0 ;
13768 char * kwnames[] = {
13769 (char *) "self",(char *) "enable", NULL
13770 };
13771
13772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
13773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13774 if (!SWIG_IsOK(res1)) {
13775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13776 }
13777 arg1 = reinterpret_cast< wxGrid * >(argp1);
13778 if (obj1) {
13779 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13780 if (!SWIG_IsOK(ecode2)) {
13781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragRowSize" "', expected argument " "2"" of type '" "bool""'");
13782 }
13783 arg2 = static_cast< bool >(val2);
13784 }
13785 {
13786 PyThreadState* __tstate = wxPyBeginAllowThreads();
13787 (arg1)->EnableDragRowSize(arg2);
13788 wxPyEndAllowThreads(__tstate);
13789 if (PyErr_Occurred()) SWIG_fail;
13790 }
13791 resultobj = SWIG_Py_Void();
13792 return resultobj;
13793 fail:
13794 return NULL;
13795 }
13796
13797
13798 SWIGINTERN PyObject *_wrap_Grid_DisableDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13799 PyObject *resultobj = 0;
13800 wxGrid *arg1 = (wxGrid *) 0 ;
13801 void *argp1 = 0 ;
13802 int res1 = 0 ;
13803 PyObject *swig_obj[1] ;
13804
13805 if (!args) SWIG_fail;
13806 swig_obj[0] = args;
13807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13808 if (!SWIG_IsOK(res1)) {
13809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13810 }
13811 arg1 = reinterpret_cast< wxGrid * >(argp1);
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 (arg1)->DisableDragRowSize();
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 resultobj = SWIG_Py_Void();
13819 return resultobj;
13820 fail:
13821 return NULL;
13822 }
13823
13824
13825 SWIGINTERN PyObject *_wrap_Grid_CanDragRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13826 PyObject *resultobj = 0;
13827 wxGrid *arg1 = (wxGrid *) 0 ;
13828 bool result;
13829 void *argp1 = 0 ;
13830 int res1 = 0 ;
13831 PyObject *swig_obj[1] ;
13832
13833 if (!args) SWIG_fail;
13834 swig_obj[0] = args;
13835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13836 if (!SWIG_IsOK(res1)) {
13837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13838 }
13839 arg1 = reinterpret_cast< wxGrid * >(argp1);
13840 {
13841 PyThreadState* __tstate = wxPyBeginAllowThreads();
13842 result = (bool)(arg1)->CanDragRowSize();
13843 wxPyEndAllowThreads(__tstate);
13844 if (PyErr_Occurred()) SWIG_fail;
13845 }
13846 {
13847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13848 }
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_Grid_EnableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13856 PyObject *resultobj = 0;
13857 wxGrid *arg1 = (wxGrid *) 0 ;
13858 bool arg2 = (bool) true ;
13859 void *argp1 = 0 ;
13860 int res1 = 0 ;
13861 bool val2 ;
13862 int ecode2 = 0 ;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 char * kwnames[] = {
13866 (char *) "self",(char *) "enable", NULL
13867 };
13868
13869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragColSize",kwnames,&obj0,&obj1)) SWIG_fail;
13870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13871 if (!SWIG_IsOK(res1)) {
13872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13873 }
13874 arg1 = reinterpret_cast< wxGrid * >(argp1);
13875 if (obj1) {
13876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13877 if (!SWIG_IsOK(ecode2)) {
13878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragColSize" "', expected argument " "2"" of type '" "bool""'");
13879 }
13880 arg2 = static_cast< bool >(val2);
13881 }
13882 {
13883 PyThreadState* __tstate = wxPyBeginAllowThreads();
13884 (arg1)->EnableDragColSize(arg2);
13885 wxPyEndAllowThreads(__tstate);
13886 if (PyErr_Occurred()) SWIG_fail;
13887 }
13888 resultobj = SWIG_Py_Void();
13889 return resultobj;
13890 fail:
13891 return NULL;
13892 }
13893
13894
13895 SWIGINTERN PyObject *_wrap_Grid_DisableDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13896 PyObject *resultobj = 0;
13897 wxGrid *arg1 = (wxGrid *) 0 ;
13898 void *argp1 = 0 ;
13899 int res1 = 0 ;
13900 PyObject *swig_obj[1] ;
13901
13902 if (!args) SWIG_fail;
13903 swig_obj[0] = args;
13904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13905 if (!SWIG_IsOK(res1)) {
13906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13907 }
13908 arg1 = reinterpret_cast< wxGrid * >(argp1);
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 (arg1)->DisableDragColSize();
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_Py_Void();
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_Grid_CanDragColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13923 PyObject *resultobj = 0;
13924 wxGrid *arg1 = (wxGrid *) 0 ;
13925 bool result;
13926 void *argp1 = 0 ;
13927 int res1 = 0 ;
13928 PyObject *swig_obj[1] ;
13929
13930 if (!args) SWIG_fail;
13931 swig_obj[0] = args;
13932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13933 if (!SWIG_IsOK(res1)) {
13934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13935 }
13936 arg1 = reinterpret_cast< wxGrid * >(argp1);
13937 {
13938 PyThreadState* __tstate = wxPyBeginAllowThreads();
13939 result = (bool)(arg1)->CanDragColSize();
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 {
13944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13945 }
13946 return resultobj;
13947 fail:
13948 return NULL;
13949 }
13950
13951
13952 SWIGINTERN PyObject *_wrap_Grid_EnableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13953 PyObject *resultobj = 0;
13954 wxGrid *arg1 = (wxGrid *) 0 ;
13955 bool arg2 = (bool) true ;
13956 void *argp1 = 0 ;
13957 int res1 = 0 ;
13958 bool val2 ;
13959 int ecode2 = 0 ;
13960 PyObject * obj0 = 0 ;
13961 PyObject * obj1 = 0 ;
13962 char * kwnames[] = {
13963 (char *) "self",(char *) "enable", NULL
13964 };
13965
13966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragGridSize",kwnames,&obj0,&obj1)) SWIG_fail;
13967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
13968 if (!SWIG_IsOK(res1)) {
13969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
13970 }
13971 arg1 = reinterpret_cast< wxGrid * >(argp1);
13972 if (obj1) {
13973 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13974 if (!SWIG_IsOK(ecode2)) {
13975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragGridSize" "', expected argument " "2"" of type '" "bool""'");
13976 }
13977 arg2 = static_cast< bool >(val2);
13978 }
13979 {
13980 PyThreadState* __tstate = wxPyBeginAllowThreads();
13981 (arg1)->EnableDragGridSize(arg2);
13982 wxPyEndAllowThreads(__tstate);
13983 if (PyErr_Occurred()) SWIG_fail;
13984 }
13985 resultobj = SWIG_Py_Void();
13986 return resultobj;
13987 fail:
13988 return NULL;
13989 }
13990
13991
13992 SWIGINTERN PyObject *_wrap_Grid_DisableDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13993 PyObject *resultobj = 0;
13994 wxGrid *arg1 = (wxGrid *) 0 ;
13995 void *argp1 = 0 ;
13996 int res1 = 0 ;
13997 PyObject *swig_obj[1] ;
13998
13999 if (!args) SWIG_fail;
14000 swig_obj[0] = args;
14001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14002 if (!SWIG_IsOK(res1)) {
14003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14004 }
14005 arg1 = reinterpret_cast< wxGrid * >(argp1);
14006 {
14007 PyThreadState* __tstate = wxPyBeginAllowThreads();
14008 (arg1)->DisableDragGridSize();
14009 wxPyEndAllowThreads(__tstate);
14010 if (PyErr_Occurred()) SWIG_fail;
14011 }
14012 resultobj = SWIG_Py_Void();
14013 return resultobj;
14014 fail:
14015 return NULL;
14016 }
14017
14018
14019 SWIGINTERN PyObject *_wrap_Grid_CanDragGridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14020 PyObject *resultobj = 0;
14021 wxGrid *arg1 = (wxGrid *) 0 ;
14022 bool result;
14023 void *argp1 = 0 ;
14024 int res1 = 0 ;
14025 PyObject *swig_obj[1] ;
14026
14027 if (!args) SWIG_fail;
14028 swig_obj[0] = args;
14029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14030 if (!SWIG_IsOK(res1)) {
14031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragGridSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14032 }
14033 arg1 = reinterpret_cast< wxGrid * >(argp1);
14034 {
14035 PyThreadState* __tstate = wxPyBeginAllowThreads();
14036 result = (bool)(arg1)->CanDragGridSize();
14037 wxPyEndAllowThreads(__tstate);
14038 if (PyErr_Occurred()) SWIG_fail;
14039 }
14040 {
14041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14042 }
14043 return resultobj;
14044 fail:
14045 return NULL;
14046 }
14047
14048
14049 SWIGINTERN PyObject *_wrap_Grid_EnableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14050 PyObject *resultobj = 0;
14051 wxGrid *arg1 = (wxGrid *) 0 ;
14052 bool arg2 = (bool) true ;
14053 void *argp1 = 0 ;
14054 int res1 = 0 ;
14055 bool val2 ;
14056 int ecode2 = 0 ;
14057 PyObject * obj0 = 0 ;
14058 PyObject * obj1 = 0 ;
14059 char * kwnames[] = {
14060 (char *) "self",(char *) "enable", NULL
14061 };
14062
14063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_EnableDragCell",kwnames,&obj0,&obj1)) SWIG_fail;
14064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14065 if (!SWIG_IsOK(res1)) {
14066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_EnableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14067 }
14068 arg1 = reinterpret_cast< wxGrid * >(argp1);
14069 if (obj1) {
14070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
14071 if (!SWIG_IsOK(ecode2)) {
14072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_EnableDragCell" "', expected argument " "2"" of type '" "bool""'");
14073 }
14074 arg2 = static_cast< bool >(val2);
14075 }
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 (arg1)->EnableDragCell(arg2);
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_Py_Void();
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_Grid_DisableDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14090 PyObject *resultobj = 0;
14091 wxGrid *arg1 = (wxGrid *) 0 ;
14092 void *argp1 = 0 ;
14093 int res1 = 0 ;
14094 PyObject *swig_obj[1] ;
14095
14096 if (!args) SWIG_fail;
14097 swig_obj[0] = args;
14098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14099 if (!SWIG_IsOK(res1)) {
14100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DisableDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14101 }
14102 arg1 = reinterpret_cast< wxGrid * >(argp1);
14103 {
14104 PyThreadState* __tstate = wxPyBeginAllowThreads();
14105 (arg1)->DisableDragCell();
14106 wxPyEndAllowThreads(__tstate);
14107 if (PyErr_Occurred()) SWIG_fail;
14108 }
14109 resultobj = SWIG_Py_Void();
14110 return resultobj;
14111 fail:
14112 return NULL;
14113 }
14114
14115
14116 SWIGINTERN PyObject *_wrap_Grid_CanDragCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14117 PyObject *resultobj = 0;
14118 wxGrid *arg1 = (wxGrid *) 0 ;
14119 bool result;
14120 void *argp1 = 0 ;
14121 int res1 = 0 ;
14122 PyObject *swig_obj[1] ;
14123
14124 if (!args) SWIG_fail;
14125 swig_obj[0] = args;
14126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14127 if (!SWIG_IsOK(res1)) {
14128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_CanDragCell" "', expected argument " "1"" of type '" "wxGrid *""'");
14129 }
14130 arg1 = reinterpret_cast< wxGrid * >(argp1);
14131 {
14132 PyThreadState* __tstate = wxPyBeginAllowThreads();
14133 result = (bool)(arg1)->CanDragCell();
14134 wxPyEndAllowThreads(__tstate);
14135 if (PyErr_Occurred()) SWIG_fail;
14136 }
14137 {
14138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14139 }
14140 return resultobj;
14141 fail:
14142 return NULL;
14143 }
14144
14145
14146 SWIGINTERN PyObject *_wrap_Grid_SetAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14147 PyObject *resultobj = 0;
14148 wxGrid *arg1 = (wxGrid *) 0 ;
14149 int arg2 ;
14150 int arg3 ;
14151 wxGridCellAttr *arg4 = (wxGridCellAttr *) 0 ;
14152 void *argp1 = 0 ;
14153 int res1 = 0 ;
14154 int val2 ;
14155 int ecode2 = 0 ;
14156 int val3 ;
14157 int ecode3 = 0 ;
14158 void *argp4 = 0 ;
14159 int res4 = 0 ;
14160 PyObject * obj0 = 0 ;
14161 PyObject * obj1 = 0 ;
14162 PyObject * obj2 = 0 ;
14163 PyObject * obj3 = 0 ;
14164 char * kwnames[] = {
14165 (char *) "self",(char *) "row",(char *) "col",(char *) "attr", NULL
14166 };
14167
14168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetAttr",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14170 if (!SWIG_IsOK(res1)) {
14171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14172 }
14173 arg1 = reinterpret_cast< wxGrid * >(argp1);
14174 ecode2 = SWIG_AsVal_int(obj1, &val2);
14175 if (!SWIG_IsOK(ecode2)) {
14176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetAttr" "', expected argument " "2"" of type '" "int""'");
14177 }
14178 arg2 = static_cast< int >(val2);
14179 ecode3 = SWIG_AsVal_int(obj2, &val3);
14180 if (!SWIG_IsOK(ecode3)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetAttr" "', expected argument " "3"" of type '" "int""'");
14182 }
14183 arg3 = static_cast< int >(val3);
14184 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14185 if (!SWIG_IsOK(res4)) {
14186 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetAttr" "', expected argument " "4"" of type '" "wxGridCellAttr *""'");
14187 }
14188 arg4 = reinterpret_cast< wxGridCellAttr * >(argp4);
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 (arg1)->SetAttr(arg2,arg3,arg4);
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 resultobj = SWIG_Py_Void();
14196 return resultobj;
14197 fail:
14198 return NULL;
14199 }
14200
14201
14202 SWIGINTERN PyObject *_wrap_Grid_SetRowAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14203 PyObject *resultobj = 0;
14204 wxGrid *arg1 = (wxGrid *) 0 ;
14205 int arg2 ;
14206 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14207 void *argp1 = 0 ;
14208 int res1 = 0 ;
14209 int val2 ;
14210 int ecode2 = 0 ;
14211 void *argp3 = 0 ;
14212 int res3 = 0 ;
14213 PyObject * obj0 = 0 ;
14214 PyObject * obj1 = 0 ;
14215 PyObject * obj2 = 0 ;
14216 char * kwnames[] = {
14217 (char *) "self",(char *) "row",(char *) "attr", NULL
14218 };
14219
14220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14222 if (!SWIG_IsOK(res1)) {
14223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14224 }
14225 arg1 = reinterpret_cast< wxGrid * >(argp1);
14226 ecode2 = SWIG_AsVal_int(obj1, &val2);
14227 if (!SWIG_IsOK(ecode2)) {
14228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowAttr" "', expected argument " "2"" of type '" "int""'");
14229 }
14230 arg2 = static_cast< int >(val2);
14231 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14232 if (!SWIG_IsOK(res3)) {
14233 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetRowAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14234 }
14235 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 (arg1)->SetRowAttr(arg2,arg3);
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 resultobj = SWIG_Py_Void();
14243 return resultobj;
14244 fail:
14245 return NULL;
14246 }
14247
14248
14249 SWIGINTERN PyObject *_wrap_Grid_SetColAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14250 PyObject *resultobj = 0;
14251 wxGrid *arg1 = (wxGrid *) 0 ;
14252 int arg2 ;
14253 wxGridCellAttr *arg3 = (wxGridCellAttr *) 0 ;
14254 void *argp1 = 0 ;
14255 int res1 = 0 ;
14256 int val2 ;
14257 int ecode2 = 0 ;
14258 void *argp3 = 0 ;
14259 int res3 = 0 ;
14260 PyObject * obj0 = 0 ;
14261 PyObject * obj1 = 0 ;
14262 PyObject * obj2 = 0 ;
14263 char * kwnames[] = {
14264 (char *) "self",(char *) "col",(char *) "attr", NULL
14265 };
14266
14267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14269 if (!SWIG_IsOK(res1)) {
14270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColAttr" "', expected argument " "1"" of type '" "wxGrid *""'");
14271 }
14272 arg1 = reinterpret_cast< wxGrid * >(argp1);
14273 ecode2 = SWIG_AsVal_int(obj1, &val2);
14274 if (!SWIG_IsOK(ecode2)) {
14275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColAttr" "', expected argument " "2"" of type '" "int""'");
14276 }
14277 arg2 = static_cast< int >(val2);
14278 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellAttr, 0 | 0 );
14279 if (!SWIG_IsOK(res3)) {
14280 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_SetColAttr" "', expected argument " "3"" of type '" "wxGridCellAttr *""'");
14281 }
14282 arg3 = reinterpret_cast< wxGridCellAttr * >(argp3);
14283 {
14284 PyThreadState* __tstate = wxPyBeginAllowThreads();
14285 (arg1)->SetColAttr(arg2,arg3);
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 resultobj = SWIG_Py_Void();
14290 return resultobj;
14291 fail:
14292 return NULL;
14293 }
14294
14295
14296 SWIGINTERN PyObject *_wrap_Grid_GetOrCreateCellAttr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14297 PyObject *resultobj = 0;
14298 wxGrid *arg1 = (wxGrid *) 0 ;
14299 int arg2 ;
14300 int arg3 ;
14301 wxGridCellAttr *result = 0 ;
14302 void *argp1 = 0 ;
14303 int res1 = 0 ;
14304 int val2 ;
14305 int ecode2 = 0 ;
14306 int val3 ;
14307 int ecode3 = 0 ;
14308 PyObject * obj0 = 0 ;
14309 PyObject * obj1 = 0 ;
14310 PyObject * obj2 = 0 ;
14311 char * kwnames[] = {
14312 (char *) "self",(char *) "row",(char *) "col", NULL
14313 };
14314
14315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetOrCreateCellAttr",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14317 if (!SWIG_IsOK(res1)) {
14318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "1"" of type '" "wxGrid const *""'");
14319 }
14320 arg1 = reinterpret_cast< wxGrid * >(argp1);
14321 ecode2 = SWIG_AsVal_int(obj1, &val2);
14322 if (!SWIG_IsOK(ecode2)) {
14323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "2"" of type '" "int""'");
14324 }
14325 arg2 = static_cast< int >(val2);
14326 ecode3 = SWIG_AsVal_int(obj2, &val3);
14327 if (!SWIG_IsOK(ecode3)) {
14328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetOrCreateCellAttr" "', expected argument " "3"" of type '" "int""'");
14329 }
14330 arg3 = static_cast< int >(val3);
14331 {
14332 PyThreadState* __tstate = wxPyBeginAllowThreads();
14333 result = (wxGridCellAttr *)((wxGrid const *)arg1)->GetOrCreateCellAttr(arg2,arg3);
14334 wxPyEndAllowThreads(__tstate);
14335 if (PyErr_Occurred()) SWIG_fail;
14336 }
14337 {
14338 resultobj = wxPyMake_wxGridCellAttr(result, (bool)0);
14339 }
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 SWIGINTERN PyObject *_wrap_Grid_SetColFormatBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj = 0;
14348 wxGrid *arg1 = (wxGrid *) 0 ;
14349 int arg2 ;
14350 void *argp1 = 0 ;
14351 int res1 = 0 ;
14352 int val2 ;
14353 int ecode2 = 0 ;
14354 PyObject * obj0 = 0 ;
14355 PyObject * obj1 = 0 ;
14356 char * kwnames[] = {
14357 (char *) "self",(char *) "col", NULL
14358 };
14359
14360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatBool",kwnames,&obj0,&obj1)) SWIG_fail;
14361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14362 if (!SWIG_IsOK(res1)) {
14363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatBool" "', expected argument " "1"" of type '" "wxGrid *""'");
14364 }
14365 arg1 = reinterpret_cast< wxGrid * >(argp1);
14366 ecode2 = SWIG_AsVal_int(obj1, &val2);
14367 if (!SWIG_IsOK(ecode2)) {
14368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatBool" "', expected argument " "2"" of type '" "int""'");
14369 }
14370 arg2 = static_cast< int >(val2);
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 (arg1)->SetColFormatBool(arg2);
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 resultobj = SWIG_Py_Void();
14378 return resultobj;
14379 fail:
14380 return NULL;
14381 }
14382
14383
14384 SWIGINTERN PyObject *_wrap_Grid_SetColFormatNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14385 PyObject *resultobj = 0;
14386 wxGrid *arg1 = (wxGrid *) 0 ;
14387 int arg2 ;
14388 void *argp1 = 0 ;
14389 int res1 = 0 ;
14390 int val2 ;
14391 int ecode2 = 0 ;
14392 PyObject * obj0 = 0 ;
14393 PyObject * obj1 = 0 ;
14394 char * kwnames[] = {
14395 (char *) "self",(char *) "col", NULL
14396 };
14397
14398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColFormatNumber",kwnames,&obj0,&obj1)) SWIG_fail;
14399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14400 if (!SWIG_IsOK(res1)) {
14401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatNumber" "', expected argument " "1"" of type '" "wxGrid *""'");
14402 }
14403 arg1 = reinterpret_cast< wxGrid * >(argp1);
14404 ecode2 = SWIG_AsVal_int(obj1, &val2);
14405 if (!SWIG_IsOK(ecode2)) {
14406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatNumber" "', expected argument " "2"" of type '" "int""'");
14407 }
14408 arg2 = static_cast< int >(val2);
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 (arg1)->SetColFormatNumber(arg2);
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 resultobj = SWIG_Py_Void();
14416 return resultobj;
14417 fail:
14418 return NULL;
14419 }
14420
14421
14422 SWIGINTERN PyObject *_wrap_Grid_SetColFormatFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14423 PyObject *resultobj = 0;
14424 wxGrid *arg1 = (wxGrid *) 0 ;
14425 int arg2 ;
14426 int arg3 = (int) -1 ;
14427 int arg4 = (int) -1 ;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 int val2 ;
14431 int ecode2 = 0 ;
14432 int val3 ;
14433 int ecode3 = 0 ;
14434 int val4 ;
14435 int ecode4 = 0 ;
14436 PyObject * obj0 = 0 ;
14437 PyObject * obj1 = 0 ;
14438 PyObject * obj2 = 0 ;
14439 PyObject * obj3 = 0 ;
14440 char * kwnames[] = {
14441 (char *) "self",(char *) "col",(char *) "width",(char *) "precision", NULL
14442 };
14443
14444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Grid_SetColFormatFloat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14446 if (!SWIG_IsOK(res1)) {
14447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatFloat" "', expected argument " "1"" of type '" "wxGrid *""'");
14448 }
14449 arg1 = reinterpret_cast< wxGrid * >(argp1);
14450 ecode2 = SWIG_AsVal_int(obj1, &val2);
14451 if (!SWIG_IsOK(ecode2)) {
14452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatFloat" "', expected argument " "2"" of type '" "int""'");
14453 }
14454 arg2 = static_cast< int >(val2);
14455 if (obj2) {
14456 ecode3 = SWIG_AsVal_int(obj2, &val3);
14457 if (!SWIG_IsOK(ecode3)) {
14458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColFormatFloat" "', expected argument " "3"" of type '" "int""'");
14459 }
14460 arg3 = static_cast< int >(val3);
14461 }
14462 if (obj3) {
14463 ecode4 = SWIG_AsVal_int(obj3, &val4);
14464 if (!SWIG_IsOK(ecode4)) {
14465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetColFormatFloat" "', expected argument " "4"" of type '" "int""'");
14466 }
14467 arg4 = static_cast< int >(val4);
14468 }
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 (arg1)->SetColFormatFloat(arg2,arg3,arg4);
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 resultobj = SWIG_Py_Void();
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 SWIGINTERN PyObject *_wrap_Grid_SetColFormatCustom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14483 PyObject *resultobj = 0;
14484 wxGrid *arg1 = (wxGrid *) 0 ;
14485 int arg2 ;
14486 wxString *arg3 = 0 ;
14487 void *argp1 = 0 ;
14488 int res1 = 0 ;
14489 int val2 ;
14490 int ecode2 = 0 ;
14491 bool temp3 = false ;
14492 PyObject * obj0 = 0 ;
14493 PyObject * obj1 = 0 ;
14494 PyObject * obj2 = 0 ;
14495 char * kwnames[] = {
14496 (char *) "self",(char *) "col",(char *) "typeName", NULL
14497 };
14498
14499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColFormatCustom",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14501 if (!SWIG_IsOK(res1)) {
14502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColFormatCustom" "', expected argument " "1"" of type '" "wxGrid *""'");
14503 }
14504 arg1 = reinterpret_cast< wxGrid * >(argp1);
14505 ecode2 = SWIG_AsVal_int(obj1, &val2);
14506 if (!SWIG_IsOK(ecode2)) {
14507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColFormatCustom" "', expected argument " "2"" of type '" "int""'");
14508 }
14509 arg2 = static_cast< int >(val2);
14510 {
14511 arg3 = wxString_in_helper(obj2);
14512 if (arg3 == NULL) SWIG_fail;
14513 temp3 = true;
14514 }
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 (arg1)->SetColFormatCustom(arg2,(wxString const &)*arg3);
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = SWIG_Py_Void();
14522 {
14523 if (temp3)
14524 delete arg3;
14525 }
14526 return resultobj;
14527 fail:
14528 {
14529 if (temp3)
14530 delete arg3;
14531 }
14532 return NULL;
14533 }
14534
14535
14536 SWIGINTERN PyObject *_wrap_Grid_EnableGridLines(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_EnableGridLines",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_EnableGridLines" "', 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_EnableGridLines" "', expected argument " "2"" of type '" "bool""'");
14560 }
14561 arg2 = static_cast< bool >(val2);
14562 }
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 (arg1)->EnableGridLines(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_GridLinesEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14577 PyObject *resultobj = 0;
14578 wxGrid *arg1 = (wxGrid *) 0 ;
14579 bool result;
14580 void *argp1 = 0 ;
14581 int res1 = 0 ;
14582 PyObject *swig_obj[1] ;
14583
14584 if (!args) SWIG_fail;
14585 swig_obj[0] = args;
14586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14587 if (!SWIG_IsOK(res1)) {
14588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GridLinesEnabled" "', expected argument " "1"" of type '" "wxGrid *""'");
14589 }
14590 arg1 = reinterpret_cast< wxGrid * >(argp1);
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 result = (bool)(arg1)->GridLinesEnabled();
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 {
14598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14599 }
14600 return resultobj;
14601 fail:
14602 return NULL;
14603 }
14604
14605
14606 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14607 PyObject *resultobj = 0;
14608 wxGrid *arg1 = (wxGrid *) 0 ;
14609 int result;
14610 void *argp1 = 0 ;
14611 int res1 = 0 ;
14612 PyObject *swig_obj[1] ;
14613
14614 if (!args) SWIG_fail;
14615 swig_obj[0] = args;
14616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14617 if (!SWIG_IsOK(res1)) {
14618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14619 }
14620 arg1 = reinterpret_cast< wxGrid * >(argp1);
14621 {
14622 PyThreadState* __tstate = wxPyBeginAllowThreads();
14623 result = (int)(arg1)->GetDefaultRowSize();
14624 wxPyEndAllowThreads(__tstate);
14625 if (PyErr_Occurred()) SWIG_fail;
14626 }
14627 resultobj = SWIG_From_int(static_cast< int >(result));
14628 return resultobj;
14629 fail:
14630 return NULL;
14631 }
14632
14633
14634 SWIGINTERN PyObject *_wrap_Grid_GetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14635 PyObject *resultobj = 0;
14636 wxGrid *arg1 = (wxGrid *) 0 ;
14637 int arg2 ;
14638 int result;
14639 void *argp1 = 0 ;
14640 int res1 = 0 ;
14641 int val2 ;
14642 int ecode2 = 0 ;
14643 PyObject * obj0 = 0 ;
14644 PyObject * obj1 = 0 ;
14645 char * kwnames[] = {
14646 (char *) "self",(char *) "row", NULL
14647 };
14648
14649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetRowSize",kwnames,&obj0,&obj1)) SWIG_fail;
14650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14651 if (!SWIG_IsOK(res1)) {
14652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14653 }
14654 arg1 = reinterpret_cast< wxGrid * >(argp1);
14655 ecode2 = SWIG_AsVal_int(obj1, &val2);
14656 if (!SWIG_IsOK(ecode2)) {
14657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetRowSize" "', expected argument " "2"" of type '" "int""'");
14658 }
14659 arg2 = static_cast< int >(val2);
14660 {
14661 PyThreadState* __tstate = wxPyBeginAllowThreads();
14662 result = (int)(arg1)->GetRowSize(arg2);
14663 wxPyEndAllowThreads(__tstate);
14664 if (PyErr_Occurred()) SWIG_fail;
14665 }
14666 resultobj = SWIG_From_int(static_cast< int >(result));
14667 return resultobj;
14668 fail:
14669 return NULL;
14670 }
14671
14672
14673 SWIGINTERN PyObject *_wrap_Grid_GetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14674 PyObject *resultobj = 0;
14675 wxGrid *arg1 = (wxGrid *) 0 ;
14676 int result;
14677 void *argp1 = 0 ;
14678 int res1 = 0 ;
14679 PyObject *swig_obj[1] ;
14680
14681 if (!args) SWIG_fail;
14682 swig_obj[0] = args;
14683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14684 if (!SWIG_IsOK(res1)) {
14685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14686 }
14687 arg1 = reinterpret_cast< wxGrid * >(argp1);
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 result = (int)(arg1)->GetDefaultColSize();
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 resultobj = SWIG_From_int(static_cast< int >(result));
14695 return resultobj;
14696 fail:
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Grid_GetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj = 0;
14703 wxGrid *arg1 = (wxGrid *) 0 ;
14704 int arg2 ;
14705 int result;
14706 void *argp1 = 0 ;
14707 int res1 = 0 ;
14708 int val2 ;
14709 int ecode2 = 0 ;
14710 PyObject * obj0 = 0 ;
14711 PyObject * obj1 = 0 ;
14712 char * kwnames[] = {
14713 (char *) "self",(char *) "col", NULL
14714 };
14715
14716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetColSize",kwnames,&obj0,&obj1)) SWIG_fail;
14717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
14720 }
14721 arg1 = reinterpret_cast< wxGrid * >(argp1);
14722 ecode2 = SWIG_AsVal_int(obj1, &val2);
14723 if (!SWIG_IsOK(ecode2)) {
14724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetColSize" "', expected argument " "2"" of type '" "int""'");
14725 }
14726 arg2 = static_cast< int >(val2);
14727 {
14728 PyThreadState* __tstate = wxPyBeginAllowThreads();
14729 result = (int)(arg1)->GetColSize(arg2);
14730 wxPyEndAllowThreads(__tstate);
14731 if (PyErr_Occurred()) SWIG_fail;
14732 }
14733 resultobj = SWIG_From_int(static_cast< int >(result));
14734 return resultobj;
14735 fail:
14736 return NULL;
14737 }
14738
14739
14740 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14741 PyObject *resultobj = 0;
14742 wxGrid *arg1 = (wxGrid *) 0 ;
14743 wxColour result;
14744 void *argp1 = 0 ;
14745 int res1 = 0 ;
14746 PyObject *swig_obj[1] ;
14747
14748 if (!args) SWIG_fail;
14749 swig_obj[0] = args;
14750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14751 if (!SWIG_IsOK(res1)) {
14752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14753 }
14754 arg1 = reinterpret_cast< wxGrid * >(argp1);
14755 {
14756 PyThreadState* __tstate = wxPyBeginAllowThreads();
14757 result = (arg1)->GetDefaultCellBackgroundColour();
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14762 return resultobj;
14763 fail:
14764 return NULL;
14765 }
14766
14767
14768 SWIGINTERN PyObject *_wrap_Grid_GetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14769 PyObject *resultobj = 0;
14770 wxGrid *arg1 = (wxGrid *) 0 ;
14771 int arg2 ;
14772 int arg3 ;
14773 wxColour result;
14774 void *argp1 = 0 ;
14775 int res1 = 0 ;
14776 int val2 ;
14777 int ecode2 = 0 ;
14778 int val3 ;
14779 int ecode3 = 0 ;
14780 PyObject * obj0 = 0 ;
14781 PyObject * obj1 = 0 ;
14782 PyObject * obj2 = 0 ;
14783 char * kwnames[] = {
14784 (char *) "self",(char *) "row",(char *) "col", NULL
14785 };
14786
14787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14789 if (!SWIG_IsOK(res1)) {
14790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14791 }
14792 arg1 = reinterpret_cast< wxGrid * >(argp1);
14793 ecode2 = SWIG_AsVal_int(obj1, &val2);
14794 if (!SWIG_IsOK(ecode2)) {
14795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
14796 }
14797 arg2 = static_cast< int >(val2);
14798 ecode3 = SWIG_AsVal_int(obj2, &val3);
14799 if (!SWIG_IsOK(ecode3)) {
14800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
14801 }
14802 arg3 = static_cast< int >(val3);
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 result = (arg1)->GetCellBackgroundColour(arg2,arg3);
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14817 PyObject *resultobj = 0;
14818 wxGrid *arg1 = (wxGrid *) 0 ;
14819 wxColour result;
14820 void *argp1 = 0 ;
14821 int res1 = 0 ;
14822 PyObject *swig_obj[1] ;
14823
14824 if (!args) SWIG_fail;
14825 swig_obj[0] = args;
14826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14829 }
14830 arg1 = reinterpret_cast< wxGrid * >(argp1);
14831 {
14832 PyThreadState* __tstate = wxPyBeginAllowThreads();
14833 result = (arg1)->GetDefaultCellTextColour();
14834 wxPyEndAllowThreads(__tstate);
14835 if (PyErr_Occurred()) SWIG_fail;
14836 }
14837 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14838 return resultobj;
14839 fail:
14840 return NULL;
14841 }
14842
14843
14844 SWIGINTERN PyObject *_wrap_Grid_GetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14845 PyObject *resultobj = 0;
14846 wxGrid *arg1 = (wxGrid *) 0 ;
14847 int arg2 ;
14848 int arg3 ;
14849 wxColour result;
14850 void *argp1 = 0 ;
14851 int res1 = 0 ;
14852 int val2 ;
14853 int ecode2 = 0 ;
14854 int val3 ;
14855 int ecode3 = 0 ;
14856 PyObject * obj0 = 0 ;
14857 PyObject * obj1 = 0 ;
14858 PyObject * obj2 = 0 ;
14859 char * kwnames[] = {
14860 (char *) "self",(char *) "row",(char *) "col", NULL
14861 };
14862
14863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellTextColour",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14865 if (!SWIG_IsOK(res1)) {
14866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
14867 }
14868 arg1 = reinterpret_cast< wxGrid * >(argp1);
14869 ecode2 = SWIG_AsVal_int(obj1, &val2);
14870 if (!SWIG_IsOK(ecode2)) {
14871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellTextColour" "', expected argument " "2"" of type '" "int""'");
14872 }
14873 arg2 = static_cast< int >(val2);
14874 ecode3 = SWIG_AsVal_int(obj2, &val3);
14875 if (!SWIG_IsOK(ecode3)) {
14876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellTextColour" "', expected argument " "3"" of type '" "int""'");
14877 }
14878 arg3 = static_cast< int >(val3);
14879 {
14880 PyThreadState* __tstate = wxPyBeginAllowThreads();
14881 result = (arg1)->GetCellTextColour(arg2,arg3);
14882 wxPyEndAllowThreads(__tstate);
14883 if (PyErr_Occurred()) SWIG_fail;
14884 }
14885 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
14886 return resultobj;
14887 fail:
14888 return NULL;
14889 }
14890
14891
14892 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14893 PyObject *resultobj = 0;
14894 wxGrid *arg1 = (wxGrid *) 0 ;
14895 wxFont result;
14896 void *argp1 = 0 ;
14897 int res1 = 0 ;
14898 PyObject *swig_obj[1] ;
14899
14900 if (!args) SWIG_fail;
14901 swig_obj[0] = args;
14902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14903 if (!SWIG_IsOK(res1)) {
14904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
14905 }
14906 arg1 = reinterpret_cast< wxGrid * >(argp1);
14907 {
14908 PyThreadState* __tstate = wxPyBeginAllowThreads();
14909 result = (arg1)->GetDefaultCellFont();
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14914 return resultobj;
14915 fail:
14916 return NULL;
14917 }
14918
14919
14920 SWIGINTERN PyObject *_wrap_Grid_GetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14921 PyObject *resultobj = 0;
14922 wxGrid *arg1 = (wxGrid *) 0 ;
14923 int arg2 ;
14924 int arg3 ;
14925 wxFont result;
14926 void *argp1 = 0 ;
14927 int res1 = 0 ;
14928 int val2 ;
14929 int ecode2 = 0 ;
14930 int val3 ;
14931 int ecode3 = 0 ;
14932 PyObject * obj0 = 0 ;
14933 PyObject * obj1 = 0 ;
14934 PyObject * obj2 = 0 ;
14935 char * kwnames[] = {
14936 (char *) "self",(char *) "row",(char *) "col", NULL
14937 };
14938
14939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellFont",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14941 if (!SWIG_IsOK(res1)) {
14942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
14943 }
14944 arg1 = reinterpret_cast< wxGrid * >(argp1);
14945 ecode2 = SWIG_AsVal_int(obj1, &val2);
14946 if (!SWIG_IsOK(ecode2)) {
14947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellFont" "', expected argument " "2"" of type '" "int""'");
14948 }
14949 arg2 = static_cast< int >(val2);
14950 ecode3 = SWIG_AsVal_int(obj2, &val3);
14951 if (!SWIG_IsOK(ecode3)) {
14952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellFont" "', expected argument " "3"" of type '" "int""'");
14953 }
14954 arg3 = static_cast< int >(val3);
14955 {
14956 PyThreadState* __tstate = wxPyBeginAllowThreads();
14957 result = (arg1)->GetCellFont(arg2,arg3);
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14969 PyObject *resultobj = 0;
14970 wxGrid *arg1 = (wxGrid *) 0 ;
14971 int *arg2 = (int *) 0 ;
14972 int *arg3 = (int *) 0 ;
14973 void *argp1 = 0 ;
14974 int res1 = 0 ;
14975 int temp2 ;
14976 int res2 = SWIG_TMPOBJ ;
14977 int temp3 ;
14978 int res3 = SWIG_TMPOBJ ;
14979 PyObject *swig_obj[1] ;
14980
14981 arg2 = &temp2;
14982 arg3 = &temp3;
14983 if (!args) SWIG_fail;
14984 swig_obj[0] = args;
14985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
14986 if (!SWIG_IsOK(res1)) {
14987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
14988 }
14989 arg1 = reinterpret_cast< wxGrid * >(argp1);
14990 {
14991 PyThreadState* __tstate = wxPyBeginAllowThreads();
14992 (arg1)->GetDefaultCellAlignment(arg2,arg3);
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 resultobj = SWIG_Py_Void();
14997 if (SWIG_IsTmpObj(res2)) {
14998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14999 } else {
15000 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15002 }
15003 if (SWIG_IsTmpObj(res3)) {
15004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
15005 } else {
15006 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15008 }
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 SWIGINTERN PyObject *_wrap_Grid_GetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15016 PyObject *resultobj = 0;
15017 wxGrid *arg1 = (wxGrid *) 0 ;
15018 int arg2 ;
15019 int arg3 ;
15020 int *arg4 = (int *) 0 ;
15021 int *arg5 = (int *) 0 ;
15022 void *argp1 = 0 ;
15023 int res1 = 0 ;
15024 int val2 ;
15025 int ecode2 = 0 ;
15026 int val3 ;
15027 int ecode3 = 0 ;
15028 int temp4 ;
15029 int res4 = SWIG_TMPOBJ ;
15030 int temp5 ;
15031 int res5 = SWIG_TMPOBJ ;
15032 PyObject * obj0 = 0 ;
15033 PyObject * obj1 = 0 ;
15034 PyObject * obj2 = 0 ;
15035 char * kwnames[] = {
15036 (char *) "self",(char *) "row",(char *) "col", NULL
15037 };
15038
15039 arg4 = &temp4;
15040 arg5 = &temp5;
15041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15043 if (!SWIG_IsOK(res1)) {
15044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
15045 }
15046 arg1 = reinterpret_cast< wxGrid * >(argp1);
15047 ecode2 = SWIG_AsVal_int(obj1, &val2);
15048 if (!SWIG_IsOK(ecode2)) {
15049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellAlignment" "', expected argument " "2"" of type '" "int""'");
15050 }
15051 arg2 = static_cast< int >(val2);
15052 ecode3 = SWIG_AsVal_int(obj2, &val3);
15053 if (!SWIG_IsOK(ecode3)) {
15054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellAlignment" "', expected argument " "3"" of type '" "int""'");
15055 }
15056 arg3 = static_cast< int >(val3);
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 (arg1)->GetCellAlignment(arg2,arg3,arg4,arg5);
15060 wxPyEndAllowThreads(__tstate);
15061 if (PyErr_Occurred()) SWIG_fail;
15062 }
15063 resultobj = SWIG_Py_Void();
15064 if (SWIG_IsTmpObj(res4)) {
15065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15066 } else {
15067 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15069 }
15070 if (SWIG_IsTmpObj(res5)) {
15071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15072 } else {
15073 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15075 }
15076 return resultobj;
15077 fail:
15078 return NULL;
15079 }
15080
15081
15082 SWIGINTERN PyObject *_wrap_Grid_GetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15083 PyObject *resultobj = 0;
15084 wxGrid *arg1 = (wxGrid *) 0 ;
15085 bool result;
15086 void *argp1 = 0 ;
15087 int res1 = 0 ;
15088 PyObject *swig_obj[1] ;
15089
15090 if (!args) SWIG_fail;
15091 swig_obj[0] = args;
15092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15093 if (!SWIG_IsOK(res1)) {
15094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15095 }
15096 arg1 = reinterpret_cast< wxGrid * >(argp1);
15097 {
15098 PyThreadState* __tstate = wxPyBeginAllowThreads();
15099 result = (bool)(arg1)->GetDefaultCellOverflow();
15100 wxPyEndAllowThreads(__tstate);
15101 if (PyErr_Occurred()) SWIG_fail;
15102 }
15103 {
15104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15105 }
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 SWIGINTERN PyObject *_wrap_Grid_GetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj = 0;
15114 wxGrid *arg1 = (wxGrid *) 0 ;
15115 int arg2 ;
15116 int arg3 ;
15117 bool result;
15118 void *argp1 = 0 ;
15119 int res1 = 0 ;
15120 int val2 ;
15121 int ecode2 = 0 ;
15122 int val3 ;
15123 int ecode3 = 0 ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 char * kwnames[] = {
15128 (char *) "self",(char *) "row",(char *) "col", NULL
15129 };
15130
15131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellOverflow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
15135 }
15136 arg1 = reinterpret_cast< wxGrid * >(argp1);
15137 ecode2 = SWIG_AsVal_int(obj1, &val2);
15138 if (!SWIG_IsOK(ecode2)) {
15139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellOverflow" "', expected argument " "2"" of type '" "int""'");
15140 }
15141 arg2 = static_cast< int >(val2);
15142 ecode3 = SWIG_AsVal_int(obj2, &val3);
15143 if (!SWIG_IsOK(ecode3)) {
15144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellOverflow" "', expected argument " "3"" of type '" "int""'");
15145 }
15146 arg3 = static_cast< int >(val3);
15147 {
15148 PyThreadState* __tstate = wxPyBeginAllowThreads();
15149 result = (bool)(arg1)->GetCellOverflow(arg2,arg3);
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 {
15154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15155 }
15156 return resultobj;
15157 fail:
15158 return NULL;
15159 }
15160
15161
15162 SWIGINTERN PyObject *_wrap_Grid_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15163 PyObject *resultobj = 0;
15164 wxGrid *arg1 = (wxGrid *) 0 ;
15165 int arg2 ;
15166 int arg3 ;
15167 int *arg4 = (int *) 0 ;
15168 int *arg5 = (int *) 0 ;
15169 void *argp1 = 0 ;
15170 int res1 = 0 ;
15171 int val2 ;
15172 int ecode2 = 0 ;
15173 int val3 ;
15174 int ecode3 = 0 ;
15175 int temp4 ;
15176 int res4 = SWIG_TMPOBJ ;
15177 int temp5 ;
15178 int res5 = SWIG_TMPOBJ ;
15179 PyObject * obj0 = 0 ;
15180 PyObject * obj1 = 0 ;
15181 PyObject * obj2 = 0 ;
15182 char * kwnames[] = {
15183 (char *) "self",(char *) "row",(char *) "col", NULL
15184 };
15185
15186 arg4 = &temp4;
15187 arg5 = &temp5;
15188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15190 if (!SWIG_IsOK(res1)) {
15191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15192 }
15193 arg1 = reinterpret_cast< wxGrid * >(argp1);
15194 ecode2 = SWIG_AsVal_int(obj1, &val2);
15195 if (!SWIG_IsOK(ecode2)) {
15196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellSize" "', expected argument " "2"" of type '" "int""'");
15197 }
15198 arg2 = static_cast< int >(val2);
15199 ecode3 = SWIG_AsVal_int(obj2, &val3);
15200 if (!SWIG_IsOK(ecode3)) {
15201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellSize" "', expected argument " "3"" of type '" "int""'");
15202 }
15203 arg3 = static_cast< int >(val3);
15204 {
15205 PyThreadState* __tstate = wxPyBeginAllowThreads();
15206 (arg1)->GetCellSize(arg2,arg3,arg4,arg5);
15207 wxPyEndAllowThreads(__tstate);
15208 if (PyErr_Occurred()) SWIG_fail;
15209 }
15210 resultobj = SWIG_Py_Void();
15211 if (SWIG_IsTmpObj(res4)) {
15212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
15213 } else {
15214 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15216 }
15217 if (SWIG_IsTmpObj(res5)) {
15218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
15219 } else {
15220 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15222 }
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj = 0;
15231 wxGrid *arg1 = (wxGrid *) 0 ;
15232 int arg2 ;
15233 bool arg3 = (bool) false ;
15234 void *argp1 = 0 ;
15235 int res1 = 0 ;
15236 int val2 ;
15237 int ecode2 = 0 ;
15238 bool val3 ;
15239 int ecode3 = 0 ;
15240 PyObject * obj0 = 0 ;
15241 PyObject * obj1 = 0 ;
15242 PyObject * obj2 = 0 ;
15243 char * kwnames[] = {
15244 (char *) "self",(char *) "height",(char *) "resizeExistingRows", NULL
15245 };
15246
15247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15249 if (!SWIG_IsOK(res1)) {
15250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15251 }
15252 arg1 = reinterpret_cast< wxGrid * >(argp1);
15253 ecode2 = SWIG_AsVal_int(obj1, &val2);
15254 if (!SWIG_IsOK(ecode2)) {
15255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "2"" of type '" "int""'");
15256 }
15257 arg2 = static_cast< int >(val2);
15258 if (obj2) {
15259 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15260 if (!SWIG_IsOK(ecode3)) {
15261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultRowSize" "', expected argument " "3"" of type '" "bool""'");
15262 }
15263 arg3 = static_cast< bool >(val3);
15264 }
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 (arg1)->SetDefaultRowSize(arg2,arg3);
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 resultobj = SWIG_Py_Void();
15272 return resultobj;
15273 fail:
15274 return NULL;
15275 }
15276
15277
15278 SWIGINTERN PyObject *_wrap_Grid_SetRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15279 PyObject *resultobj = 0;
15280 wxGrid *arg1 = (wxGrid *) 0 ;
15281 int arg2 ;
15282 int arg3 ;
15283 void *argp1 = 0 ;
15284 int res1 = 0 ;
15285 int val2 ;
15286 int ecode2 = 0 ;
15287 int val3 ;
15288 int ecode3 = 0 ;
15289 PyObject * obj0 = 0 ;
15290 PyObject * obj1 = 0 ;
15291 PyObject * obj2 = 0 ;
15292 char * kwnames[] = {
15293 (char *) "self",(char *) "row",(char *) "height", NULL
15294 };
15295
15296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15300 }
15301 arg1 = reinterpret_cast< wxGrid * >(argp1);
15302 ecode2 = SWIG_AsVal_int(obj1, &val2);
15303 if (!SWIG_IsOK(ecode2)) {
15304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowSize" "', expected argument " "2"" of type '" "int""'");
15305 }
15306 arg2 = static_cast< int >(val2);
15307 ecode3 = SWIG_AsVal_int(obj2, &val3);
15308 if (!SWIG_IsOK(ecode3)) {
15309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowSize" "', expected argument " "3"" of type '" "int""'");
15310 }
15311 arg3 = static_cast< int >(val3);
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 (arg1)->SetRowSize(arg2,arg3);
15315 wxPyEndAllowThreads(__tstate);
15316 if (PyErr_Occurred()) SWIG_fail;
15317 }
15318 resultobj = SWIG_Py_Void();
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 SWIGINTERN PyObject *_wrap_Grid_SetDefaultColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj = 0;
15327 wxGrid *arg1 = (wxGrid *) 0 ;
15328 int arg2 ;
15329 bool arg3 = (bool) false ;
15330 void *argp1 = 0 ;
15331 int res1 = 0 ;
15332 int val2 ;
15333 int ecode2 = 0 ;
15334 bool val3 ;
15335 int ecode3 = 0 ;
15336 PyObject * obj0 = 0 ;
15337 PyObject * obj1 = 0 ;
15338 PyObject * obj2 = 0 ;
15339 char * kwnames[] = {
15340 (char *) "self",(char *) "width",(char *) "resizeExistingCols", NULL
15341 };
15342
15343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SetDefaultColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15345 if (!SWIG_IsOK(res1)) {
15346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15347 }
15348 arg1 = reinterpret_cast< wxGrid * >(argp1);
15349 ecode2 = SWIG_AsVal_int(obj1, &val2);
15350 if (!SWIG_IsOK(ecode2)) {
15351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultColSize" "', expected argument " "2"" of type '" "int""'");
15352 }
15353 arg2 = static_cast< int >(val2);
15354 if (obj2) {
15355 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15356 if (!SWIG_IsOK(ecode3)) {
15357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultColSize" "', expected argument " "3"" of type '" "bool""'");
15358 }
15359 arg3 = static_cast< bool >(val3);
15360 }
15361 {
15362 PyThreadState* __tstate = wxPyBeginAllowThreads();
15363 (arg1)->SetDefaultColSize(arg2,arg3);
15364 wxPyEndAllowThreads(__tstate);
15365 if (PyErr_Occurred()) SWIG_fail;
15366 }
15367 resultobj = SWIG_Py_Void();
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 SWIGINTERN PyObject *_wrap_Grid_SetColSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15375 PyObject *resultobj = 0;
15376 wxGrid *arg1 = (wxGrid *) 0 ;
15377 int arg2 ;
15378 int arg3 ;
15379 void *argp1 = 0 ;
15380 int res1 = 0 ;
15381 int val2 ;
15382 int ecode2 = 0 ;
15383 int val3 ;
15384 int ecode3 = 0 ;
15385 PyObject * obj0 = 0 ;
15386 PyObject * obj1 = 0 ;
15387 PyObject * obj2 = 0 ;
15388 char * kwnames[] = {
15389 (char *) "self",(char *) "col",(char *) "width", NULL
15390 };
15391
15392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15396 }
15397 arg1 = reinterpret_cast< wxGrid * >(argp1);
15398 ecode2 = SWIG_AsVal_int(obj1, &val2);
15399 if (!SWIG_IsOK(ecode2)) {
15400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColSize" "', expected argument " "2"" of type '" "int""'");
15401 }
15402 arg2 = static_cast< int >(val2);
15403 ecode3 = SWIG_AsVal_int(obj2, &val3);
15404 if (!SWIG_IsOK(ecode3)) {
15405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColSize" "', expected argument " "3"" of type '" "int""'");
15406 }
15407 arg3 = static_cast< int >(val3);
15408 {
15409 PyThreadState* __tstate = wxPyBeginAllowThreads();
15410 (arg1)->SetColSize(arg2,arg3);
15411 wxPyEndAllowThreads(__tstate);
15412 if (PyErr_Occurred()) SWIG_fail;
15413 }
15414 resultobj = SWIG_Py_Void();
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15422 PyObject *resultobj = 0;
15423 wxGrid *arg1 = (wxGrid *) 0 ;
15424 int arg2 ;
15425 bool arg3 = (bool) true ;
15426 void *argp1 = 0 ;
15427 int res1 = 0 ;
15428 int val2 ;
15429 int ecode2 = 0 ;
15430 bool val3 ;
15431 int ecode3 = 0 ;
15432 PyObject * obj0 = 0 ;
15433 PyObject * obj1 = 0 ;
15434 PyObject * obj2 = 0 ;
15435 char * kwnames[] = {
15436 (char *) "self",(char *) "col",(char *) "setAsMin", NULL
15437 };
15438
15439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeColumn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15441 if (!SWIG_IsOK(res1)) {
15442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumn" "', expected argument " "1"" of type '" "wxGrid *""'");
15443 }
15444 arg1 = reinterpret_cast< wxGrid * >(argp1);
15445 ecode2 = SWIG_AsVal_int(obj1, &val2);
15446 if (!SWIG_IsOK(ecode2)) {
15447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumn" "', expected argument " "2"" of type '" "int""'");
15448 }
15449 arg2 = static_cast< int >(val2);
15450 if (obj2) {
15451 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15452 if (!SWIG_IsOK(ecode3)) {
15453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeColumn" "', expected argument " "3"" of type '" "bool""'");
15454 }
15455 arg3 = static_cast< bool >(val3);
15456 }
15457 {
15458 PyThreadState* __tstate = wxPyBeginAllowThreads();
15459 (arg1)->AutoSizeColumn(arg2,arg3);
15460 wxPyEndAllowThreads(__tstate);
15461 if (PyErr_Occurred()) SWIG_fail;
15462 }
15463 resultobj = SWIG_Py_Void();
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj = 0;
15472 wxGrid *arg1 = (wxGrid *) 0 ;
15473 int arg2 ;
15474 bool arg3 = (bool) true ;
15475 void *argp1 = 0 ;
15476 int res1 = 0 ;
15477 int val2 ;
15478 int ecode2 = 0 ;
15479 bool val3 ;
15480 int ecode3 = 0 ;
15481 PyObject * obj0 = 0 ;
15482 PyObject * obj1 = 0 ;
15483 PyObject * obj2 = 0 ;
15484 char * kwnames[] = {
15485 (char *) "self",(char *) "row",(char *) "setAsMin", NULL
15486 };
15487
15488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_AutoSizeRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15490 if (!SWIG_IsOK(res1)) {
15491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRow" "', expected argument " "1"" of type '" "wxGrid *""'");
15492 }
15493 arg1 = reinterpret_cast< wxGrid * >(argp1);
15494 ecode2 = SWIG_AsVal_int(obj1, &val2);
15495 if (!SWIG_IsOK(ecode2)) {
15496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRow" "', expected argument " "2"" of type '" "int""'");
15497 }
15498 arg2 = static_cast< int >(val2);
15499 if (obj2) {
15500 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15501 if (!SWIG_IsOK(ecode3)) {
15502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_AutoSizeRow" "', expected argument " "3"" of type '" "bool""'");
15503 }
15504 arg3 = static_cast< bool >(val3);
15505 }
15506 {
15507 PyThreadState* __tstate = wxPyBeginAllowThreads();
15508 (arg1)->AutoSizeRow(arg2,arg3);
15509 wxPyEndAllowThreads(__tstate);
15510 if (PyErr_Occurred()) SWIG_fail;
15511 }
15512 resultobj = SWIG_Py_Void();
15513 return resultobj;
15514 fail:
15515 return NULL;
15516 }
15517
15518
15519 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15520 PyObject *resultobj = 0;
15521 wxGrid *arg1 = (wxGrid *) 0 ;
15522 bool arg2 = (bool) true ;
15523 void *argp1 = 0 ;
15524 int res1 = 0 ;
15525 bool val2 ;
15526 int ecode2 = 0 ;
15527 PyObject * obj0 = 0 ;
15528 PyObject * obj1 = 0 ;
15529 char * kwnames[] = {
15530 (char *) "self",(char *) "setAsMin", NULL
15531 };
15532
15533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeColumns",kwnames,&obj0,&obj1)) SWIG_fail;
15534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15535 if (!SWIG_IsOK(res1)) {
15536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColumns" "', expected argument " "1"" of type '" "wxGrid *""'");
15537 }
15538 arg1 = reinterpret_cast< wxGrid * >(argp1);
15539 if (obj1) {
15540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15541 if (!SWIG_IsOK(ecode2)) {
15542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColumns" "', expected argument " "2"" of type '" "bool""'");
15543 }
15544 arg2 = static_cast< bool >(val2);
15545 }
15546 {
15547 PyThreadState* __tstate = wxPyBeginAllowThreads();
15548 (arg1)->AutoSizeColumns(arg2);
15549 wxPyEndAllowThreads(__tstate);
15550 if (PyErr_Occurred()) SWIG_fail;
15551 }
15552 resultobj = SWIG_Py_Void();
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15560 PyObject *resultobj = 0;
15561 wxGrid *arg1 = (wxGrid *) 0 ;
15562 bool arg2 = (bool) true ;
15563 void *argp1 = 0 ;
15564 int res1 = 0 ;
15565 bool val2 ;
15566 int ecode2 = 0 ;
15567 PyObject * obj0 = 0 ;
15568 PyObject * obj1 = 0 ;
15569 char * kwnames[] = {
15570 (char *) "self",(char *) "setAsMin", NULL
15571 };
15572
15573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Grid_AutoSizeRows",kwnames,&obj0,&obj1)) SWIG_fail;
15574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15575 if (!SWIG_IsOK(res1)) {
15576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRows" "', expected argument " "1"" of type '" "wxGrid *""'");
15577 }
15578 arg1 = reinterpret_cast< wxGrid * >(argp1);
15579 if (obj1) {
15580 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15581 if (!SWIG_IsOK(ecode2)) {
15582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRows" "', expected argument " "2"" of type '" "bool""'");
15583 }
15584 arg2 = static_cast< bool >(val2);
15585 }
15586 {
15587 PyThreadState* __tstate = wxPyBeginAllowThreads();
15588 (arg1)->AutoSizeRows(arg2);
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 resultobj = SWIG_Py_Void();
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 SWIGINTERN PyObject *_wrap_Grid_AutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15600 PyObject *resultobj = 0;
15601 wxGrid *arg1 = (wxGrid *) 0 ;
15602 void *argp1 = 0 ;
15603 int res1 = 0 ;
15604 PyObject *swig_obj[1] ;
15605
15606 if (!args) SWIG_fail;
15607 swig_obj[0] = args;
15608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15609 if (!SWIG_IsOK(res1)) {
15610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15611 }
15612 arg1 = reinterpret_cast< wxGrid * >(argp1);
15613 {
15614 PyThreadState* __tstate = wxPyBeginAllowThreads();
15615 (arg1)->AutoSize();
15616 wxPyEndAllowThreads(__tstate);
15617 if (PyErr_Occurred()) SWIG_fail;
15618 }
15619 resultobj = SWIG_Py_Void();
15620 return resultobj;
15621 fail:
15622 return NULL;
15623 }
15624
15625
15626 SWIGINTERN PyObject *_wrap_Grid_AutoSizeRowLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15627 PyObject *resultobj = 0;
15628 wxGrid *arg1 = (wxGrid *) 0 ;
15629 int arg2 ;
15630 void *argp1 = 0 ;
15631 int res1 = 0 ;
15632 int val2 ;
15633 int ecode2 = 0 ;
15634 PyObject * obj0 = 0 ;
15635 PyObject * obj1 = 0 ;
15636 char * kwnames[] = {
15637 (char *) "self",(char *) "row", NULL
15638 };
15639
15640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeRowLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15642 if (!SWIG_IsOK(res1)) {
15643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15644 }
15645 arg1 = reinterpret_cast< wxGrid * >(argp1);
15646 ecode2 = SWIG_AsVal_int(obj1, &val2);
15647 if (!SWIG_IsOK(ecode2)) {
15648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeRowLabelSize" "', expected argument " "2"" of type '" "int""'");
15649 }
15650 arg2 = static_cast< int >(val2);
15651 {
15652 PyThreadState* __tstate = wxPyBeginAllowThreads();
15653 (arg1)->AutoSizeRowLabelSize(arg2);
15654 wxPyEndAllowThreads(__tstate);
15655 if (PyErr_Occurred()) SWIG_fail;
15656 }
15657 resultobj = SWIG_Py_Void();
15658 return resultobj;
15659 fail:
15660 return NULL;
15661 }
15662
15663
15664 SWIGINTERN PyObject *_wrap_Grid_AutoSizeColLabelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15665 PyObject *resultobj = 0;
15666 wxGrid *arg1 = (wxGrid *) 0 ;
15667 int arg2 ;
15668 void *argp1 = 0 ;
15669 int res1 = 0 ;
15670 int val2 ;
15671 int ecode2 = 0 ;
15672 PyObject * obj0 = 0 ;
15673 PyObject * obj1 = 0 ;
15674 char * kwnames[] = {
15675 (char *) "self",(char *) "col", NULL
15676 };
15677
15678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_AutoSizeColLabelSize",kwnames,&obj0,&obj1)) SWIG_fail;
15679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15680 if (!SWIG_IsOK(res1)) {
15681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "1"" of type '" "wxGrid *""'");
15682 }
15683 arg1 = reinterpret_cast< wxGrid * >(argp1);
15684 ecode2 = SWIG_AsVal_int(obj1, &val2);
15685 if (!SWIG_IsOK(ecode2)) {
15686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_AutoSizeColLabelSize" "', expected argument " "2"" of type '" "int""'");
15687 }
15688 arg2 = static_cast< int >(val2);
15689 {
15690 PyThreadState* __tstate = wxPyBeginAllowThreads();
15691 (arg1)->AutoSizeColLabelSize(arg2);
15692 wxPyEndAllowThreads(__tstate);
15693 if (PyErr_Occurred()) SWIG_fail;
15694 }
15695 resultobj = SWIG_Py_Void();
15696 return resultobj;
15697 fail:
15698 return NULL;
15699 }
15700
15701
15702 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15703 PyObject *resultobj = 0;
15704 wxGrid *arg1 = (wxGrid *) 0 ;
15705 int arg2 ;
15706 int arg3 ;
15707 void *argp1 = 0 ;
15708 int res1 = 0 ;
15709 int val2 ;
15710 int ecode2 = 0 ;
15711 int val3 ;
15712 int ecode3 = 0 ;
15713 PyObject * obj0 = 0 ;
15714 PyObject * obj1 = 0 ;
15715 PyObject * obj2 = 0 ;
15716 char * kwnames[] = {
15717 (char *) "self",(char *) "col",(char *) "width", NULL
15718 };
15719
15720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetColMinimalWidth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15722 if (!SWIG_IsOK(res1)) {
15723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15724 }
15725 arg1 = reinterpret_cast< wxGrid * >(argp1);
15726 ecode2 = SWIG_AsVal_int(obj1, &val2);
15727 if (!SWIG_IsOK(ecode2)) {
15728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "2"" of type '" "int""'");
15729 }
15730 arg2 = static_cast< int >(val2);
15731 ecode3 = SWIG_AsVal_int(obj2, &val3);
15732 if (!SWIG_IsOK(ecode3)) {
15733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetColMinimalWidth" "', expected argument " "3"" of type '" "int""'");
15734 }
15735 arg3 = static_cast< int >(val3);
15736 {
15737 PyThreadState* __tstate = wxPyBeginAllowThreads();
15738 (arg1)->SetColMinimalWidth(arg2,arg3);
15739 wxPyEndAllowThreads(__tstate);
15740 if (PyErr_Occurred()) SWIG_fail;
15741 }
15742 resultobj = SWIG_Py_Void();
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15750 PyObject *resultobj = 0;
15751 wxGrid *arg1 = (wxGrid *) 0 ;
15752 int arg2 ;
15753 int arg3 ;
15754 void *argp1 = 0 ;
15755 int res1 = 0 ;
15756 int val2 ;
15757 int ecode2 = 0 ;
15758 int val3 ;
15759 int ecode3 = 0 ;
15760 PyObject * obj0 = 0 ;
15761 PyObject * obj1 = 0 ;
15762 PyObject * obj2 = 0 ;
15763 char * kwnames[] = {
15764 (char *) "self",(char *) "row",(char *) "width", NULL
15765 };
15766
15767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetRowMinimalHeight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15769 if (!SWIG_IsOK(res1)) {
15770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
15771 }
15772 arg1 = reinterpret_cast< wxGrid * >(argp1);
15773 ecode2 = SWIG_AsVal_int(obj1, &val2);
15774 if (!SWIG_IsOK(ecode2)) {
15775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "2"" of type '" "int""'");
15776 }
15777 arg2 = static_cast< int >(val2);
15778 ecode3 = SWIG_AsVal_int(obj2, &val3);
15779 if (!SWIG_IsOK(ecode3)) {
15780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetRowMinimalHeight" "', expected argument " "3"" of type '" "int""'");
15781 }
15782 arg3 = static_cast< int >(val3);
15783 {
15784 PyThreadState* __tstate = wxPyBeginAllowThreads();
15785 (arg1)->SetRowMinimalHeight(arg2,arg3);
15786 wxPyEndAllowThreads(__tstate);
15787 if (PyErr_Occurred()) SWIG_fail;
15788 }
15789 resultobj = SWIG_Py_Void();
15790 return resultobj;
15791 fail:
15792 return NULL;
15793 }
15794
15795
15796 SWIGINTERN PyObject *_wrap_Grid_SetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15797 PyObject *resultobj = 0;
15798 wxGrid *arg1 = (wxGrid *) 0 ;
15799 int arg2 ;
15800 void *argp1 = 0 ;
15801 int res1 = 0 ;
15802 int val2 ;
15803 int ecode2 = 0 ;
15804 PyObject * obj0 = 0 ;
15805 PyObject * obj1 = 0 ;
15806 char * kwnames[] = {
15807 (char *) "self",(char *) "width", NULL
15808 };
15809
15810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetColMinimalAcceptableWidth",kwnames,&obj0,&obj1)) SWIG_fail;
15811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid *""'");
15814 }
15815 arg1 = reinterpret_cast< wxGrid * >(argp1);
15816 ecode2 = SWIG_AsVal_int(obj1, &val2);
15817 if (!SWIG_IsOK(ecode2)) {
15818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetColMinimalAcceptableWidth" "', expected argument " "2"" of type '" "int""'");
15819 }
15820 arg2 = static_cast< int >(val2);
15821 {
15822 PyThreadState* __tstate = wxPyBeginAllowThreads();
15823 (arg1)->SetColMinimalAcceptableWidth(arg2);
15824 wxPyEndAllowThreads(__tstate);
15825 if (PyErr_Occurred()) SWIG_fail;
15826 }
15827 resultobj = SWIG_Py_Void();
15828 return resultobj;
15829 fail:
15830 return NULL;
15831 }
15832
15833
15834 SWIGINTERN PyObject *_wrap_Grid_SetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15835 PyObject *resultobj = 0;
15836 wxGrid *arg1 = (wxGrid *) 0 ;
15837 int arg2 ;
15838 void *argp1 = 0 ;
15839 int res1 = 0 ;
15840 int val2 ;
15841 int ecode2 = 0 ;
15842 PyObject * obj0 = 0 ;
15843 PyObject * obj1 = 0 ;
15844 char * kwnames[] = {
15845 (char *) "self",(char *) "width", NULL
15846 };
15847
15848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetRowMinimalAcceptableHeight",kwnames,&obj0,&obj1)) SWIG_fail;
15849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15850 if (!SWIG_IsOK(res1)) {
15851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid *""'");
15852 }
15853 arg1 = reinterpret_cast< wxGrid * >(argp1);
15854 ecode2 = SWIG_AsVal_int(obj1, &val2);
15855 if (!SWIG_IsOK(ecode2)) {
15856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetRowMinimalAcceptableHeight" "', expected argument " "2"" of type '" "int""'");
15857 }
15858 arg2 = static_cast< int >(val2);
15859 {
15860 PyThreadState* __tstate = wxPyBeginAllowThreads();
15861 (arg1)->SetRowMinimalAcceptableHeight(arg2);
15862 wxPyEndAllowThreads(__tstate);
15863 if (PyErr_Occurred()) SWIG_fail;
15864 }
15865 resultobj = SWIG_Py_Void();
15866 return resultobj;
15867 fail:
15868 return NULL;
15869 }
15870
15871
15872 SWIGINTERN PyObject *_wrap_Grid_GetColMinimalAcceptableWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15873 PyObject *resultobj = 0;
15874 wxGrid *arg1 = (wxGrid *) 0 ;
15875 int result;
15876 void *argp1 = 0 ;
15877 int res1 = 0 ;
15878 PyObject *swig_obj[1] ;
15879
15880 if (!args) SWIG_fail;
15881 swig_obj[0] = args;
15882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15883 if (!SWIG_IsOK(res1)) {
15884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetColMinimalAcceptableWidth" "', expected argument " "1"" of type '" "wxGrid const *""'");
15885 }
15886 arg1 = reinterpret_cast< wxGrid * >(argp1);
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 result = (int)((wxGrid const *)arg1)->GetColMinimalAcceptableWidth();
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 resultobj = SWIG_From_int(static_cast< int >(result));
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 SWIGINTERN PyObject *_wrap_Grid_GetRowMinimalAcceptableHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15901 PyObject *resultobj = 0;
15902 wxGrid *arg1 = (wxGrid *) 0 ;
15903 int result;
15904 void *argp1 = 0 ;
15905 int res1 = 0 ;
15906 PyObject *swig_obj[1] ;
15907
15908 if (!args) SWIG_fail;
15909 swig_obj[0] = args;
15910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15911 if (!SWIG_IsOK(res1)) {
15912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetRowMinimalAcceptableHeight" "', expected argument " "1"" of type '" "wxGrid const *""'");
15913 }
15914 arg1 = reinterpret_cast< wxGrid * >(argp1);
15915 {
15916 PyThreadState* __tstate = wxPyBeginAllowThreads();
15917 result = (int)((wxGrid const *)arg1)->GetRowMinimalAcceptableHeight();
15918 wxPyEndAllowThreads(__tstate);
15919 if (PyErr_Occurred()) SWIG_fail;
15920 }
15921 resultobj = SWIG_From_int(static_cast< int >(result));
15922 return resultobj;
15923 fail:
15924 return NULL;
15925 }
15926
15927
15928 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15929 PyObject *resultobj = 0;
15930 wxGrid *arg1 = (wxGrid *) 0 ;
15931 wxColour *arg2 = 0 ;
15932 void *argp1 = 0 ;
15933 int res1 = 0 ;
15934 wxColour temp2 ;
15935 PyObject * obj0 = 0 ;
15936 PyObject * obj1 = 0 ;
15937 char * kwnames[] = {
15938 (char *) "self",(char *)"arg2", NULL
15939 };
15940
15941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
15942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15943 if (!SWIG_IsOK(res1)) {
15944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15945 }
15946 arg1 = reinterpret_cast< wxGrid * >(argp1);
15947 {
15948 arg2 = &temp2;
15949 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15950 }
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 (arg1)->SetDefaultCellBackgroundColour((wxColour const &)*arg2);
15954 wxPyEndAllowThreads(__tstate);
15955 if (PyErr_Occurred()) SWIG_fail;
15956 }
15957 resultobj = SWIG_Py_Void();
15958 return resultobj;
15959 fail:
15960 return NULL;
15961 }
15962
15963
15964 SWIGINTERN PyObject *_wrap_Grid_SetCellBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15965 PyObject *resultobj = 0;
15966 wxGrid *arg1 = (wxGrid *) 0 ;
15967 int arg2 ;
15968 int arg3 ;
15969 wxColour *arg4 = 0 ;
15970 void *argp1 = 0 ;
15971 int res1 = 0 ;
15972 int val2 ;
15973 int ecode2 = 0 ;
15974 int val3 ;
15975 int ecode3 = 0 ;
15976 wxColour temp4 ;
15977 PyObject * obj0 = 0 ;
15978 PyObject * obj1 = 0 ;
15979 PyObject * obj2 = 0 ;
15980 PyObject * obj3 = 0 ;
15981 char * kwnames[] = {
15982 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
15983 };
15984
15985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellBackgroundColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
15987 if (!SWIG_IsOK(res1)) {
15988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "1"" of type '" "wxGrid *""'");
15989 }
15990 arg1 = reinterpret_cast< wxGrid * >(argp1);
15991 ecode2 = SWIG_AsVal_int(obj1, &val2);
15992 if (!SWIG_IsOK(ecode2)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "2"" of type '" "int""'");
15994 }
15995 arg2 = static_cast< int >(val2);
15996 ecode3 = SWIG_AsVal_int(obj2, &val3);
15997 if (!SWIG_IsOK(ecode3)) {
15998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellBackgroundColour" "', expected argument " "3"" of type '" "int""'");
15999 }
16000 arg3 = static_cast< int >(val3);
16001 {
16002 arg4 = &temp4;
16003 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16004 }
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 (arg1)->SetCellBackgroundColour(arg2,arg3,(wxColour const &)*arg4);
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 resultobj = SWIG_Py_Void();
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16019 PyObject *resultobj = 0;
16020 wxGrid *arg1 = (wxGrid *) 0 ;
16021 wxColour *arg2 = 0 ;
16022 void *argp1 = 0 ;
16023 int res1 = 0 ;
16024 wxColour temp2 ;
16025 PyObject * obj0 = 0 ;
16026 PyObject * obj1 = 0 ;
16027 char * kwnames[] = {
16028 (char *) "self",(char *)"arg2", NULL
16029 };
16030
16031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
16032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16033 if (!SWIG_IsOK(res1)) {
16034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16035 }
16036 arg1 = reinterpret_cast< wxGrid * >(argp1);
16037 {
16038 arg2 = &temp2;
16039 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16040 }
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 (arg1)->SetDefaultCellTextColour((wxColour const &)*arg2);
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 resultobj = SWIG_Py_Void();
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 SWIGINTERN PyObject *_wrap_Grid_SetCellTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj = 0;
16056 wxGrid *arg1 = (wxGrid *) 0 ;
16057 int arg2 ;
16058 int arg3 ;
16059 wxColour *arg4 = 0 ;
16060 void *argp1 = 0 ;
16061 int res1 = 0 ;
16062 int val2 ;
16063 int ecode2 = 0 ;
16064 int val3 ;
16065 int ecode3 = 0 ;
16066 wxColour temp4 ;
16067 PyObject * obj0 = 0 ;
16068 PyObject * obj1 = 0 ;
16069 PyObject * obj2 = 0 ;
16070 PyObject * obj3 = 0 ;
16071 char * kwnames[] = {
16072 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16073 };
16074
16075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellTextColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16077 if (!SWIG_IsOK(res1)) {
16078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellTextColour" "', expected argument " "1"" of type '" "wxGrid *""'");
16079 }
16080 arg1 = reinterpret_cast< wxGrid * >(argp1);
16081 ecode2 = SWIG_AsVal_int(obj1, &val2);
16082 if (!SWIG_IsOK(ecode2)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellTextColour" "', expected argument " "2"" of type '" "int""'");
16084 }
16085 arg2 = static_cast< int >(val2);
16086 ecode3 = SWIG_AsVal_int(obj2, &val3);
16087 if (!SWIG_IsOK(ecode3)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellTextColour" "', expected argument " "3"" of type '" "int""'");
16089 }
16090 arg3 = static_cast< int >(val3);
16091 {
16092 arg4 = &temp4;
16093 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
16094 }
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 (arg1)->SetCellTextColour(arg2,arg3,(wxColour const &)*arg4);
16098 wxPyEndAllowThreads(__tstate);
16099 if (PyErr_Occurred()) SWIG_fail;
16100 }
16101 resultobj = SWIG_Py_Void();
16102 return resultobj;
16103 fail:
16104 return NULL;
16105 }
16106
16107
16108 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj = 0;
16110 wxGrid *arg1 = (wxGrid *) 0 ;
16111 wxFont *arg2 = 0 ;
16112 void *argp1 = 0 ;
16113 int res1 = 0 ;
16114 void *argp2 = 0 ;
16115 int res2 = 0 ;
16116 PyObject * obj0 = 0 ;
16117 PyObject * obj1 = 0 ;
16118 char * kwnames[] = {
16119 (char *) "self",(char *)"arg2", NULL
16120 };
16121
16122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellFont",kwnames,&obj0,&obj1)) SWIG_fail;
16123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16124 if (!SWIG_IsOK(res1)) {
16125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16126 }
16127 arg1 = reinterpret_cast< wxGrid * >(argp1);
16128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
16129 if (!SWIG_IsOK(res2)) {
16130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16131 }
16132 if (!argp2) {
16133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetDefaultCellFont" "', expected argument " "2"" of type '" "wxFont const &""'");
16134 }
16135 arg2 = reinterpret_cast< wxFont * >(argp2);
16136 {
16137 PyThreadState* __tstate = wxPyBeginAllowThreads();
16138 (arg1)->SetDefaultCellFont((wxFont const &)*arg2);
16139 wxPyEndAllowThreads(__tstate);
16140 if (PyErr_Occurred()) SWIG_fail;
16141 }
16142 resultobj = SWIG_Py_Void();
16143 return resultobj;
16144 fail:
16145 return NULL;
16146 }
16147
16148
16149 SWIGINTERN PyObject *_wrap_Grid_SetCellFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16150 PyObject *resultobj = 0;
16151 wxGrid *arg1 = (wxGrid *) 0 ;
16152 int arg2 ;
16153 int arg3 ;
16154 wxFont *arg4 = 0 ;
16155 void *argp1 = 0 ;
16156 int res1 = 0 ;
16157 int val2 ;
16158 int ecode2 = 0 ;
16159 int val3 ;
16160 int ecode3 = 0 ;
16161 void *argp4 = 0 ;
16162 int res4 = 0 ;
16163 PyObject * obj0 = 0 ;
16164 PyObject * obj1 = 0 ;
16165 PyObject * obj2 = 0 ;
16166 PyObject * obj3 = 0 ;
16167 char * kwnames[] = {
16168 (char *) "self",(char *) "row",(char *) "col",(char *)"arg4", NULL
16169 };
16170
16171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellFont",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16173 if (!SWIG_IsOK(res1)) {
16174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellFont" "', expected argument " "1"" of type '" "wxGrid *""'");
16175 }
16176 arg1 = reinterpret_cast< wxGrid * >(argp1);
16177 ecode2 = SWIG_AsVal_int(obj1, &val2);
16178 if (!SWIG_IsOK(ecode2)) {
16179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellFont" "', expected argument " "2"" of type '" "int""'");
16180 }
16181 arg2 = static_cast< int >(val2);
16182 ecode3 = SWIG_AsVal_int(obj2, &val3);
16183 if (!SWIG_IsOK(ecode3)) {
16184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellFont" "', expected argument " "3"" of type '" "int""'");
16185 }
16186 arg3 = static_cast< int >(val3);
16187 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxFont, 0 | 0);
16188 if (!SWIG_IsOK(res4)) {
16189 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16190 }
16191 if (!argp4) {
16192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Grid_SetCellFont" "', expected argument " "4"" of type '" "wxFont const &""'");
16193 }
16194 arg4 = reinterpret_cast< wxFont * >(argp4);
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 (arg1)->SetCellFont(arg2,arg3,(wxFont const &)*arg4);
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 resultobj = SWIG_Py_Void();
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16209 PyObject *resultobj = 0;
16210 wxGrid *arg1 = (wxGrid *) 0 ;
16211 int arg2 ;
16212 int arg3 ;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 int val2 ;
16216 int ecode2 = 0 ;
16217 int val3 ;
16218 int ecode3 = 0 ;
16219 PyObject * obj0 = 0 ;
16220 PyObject * obj1 = 0 ;
16221 PyObject * obj2 = 0 ;
16222 char * kwnames[] = {
16223 (char *) "self",(char *) "horiz",(char *) "vert", NULL
16224 };
16225
16226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetDefaultCellAlignment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16228 if (!SWIG_IsOK(res1)) {
16229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16230 }
16231 arg1 = reinterpret_cast< wxGrid * >(argp1);
16232 ecode2 = SWIG_AsVal_int(obj1, &val2);
16233 if (!SWIG_IsOK(ecode2)) {
16234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "2"" of type '" "int""'");
16235 }
16236 arg2 = static_cast< int >(val2);
16237 ecode3 = SWIG_AsVal_int(obj2, &val3);
16238 if (!SWIG_IsOK(ecode3)) {
16239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetDefaultCellAlignment" "', expected argument " "3"" of type '" "int""'");
16240 }
16241 arg3 = static_cast< int >(val3);
16242 {
16243 PyThreadState* __tstate = wxPyBeginAllowThreads();
16244 (arg1)->SetDefaultCellAlignment(arg2,arg3);
16245 wxPyEndAllowThreads(__tstate);
16246 if (PyErr_Occurred()) SWIG_fail;
16247 }
16248 resultobj = SWIG_Py_Void();
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 SWIGINTERN PyObject *_wrap_Grid_SetCellAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj = 0;
16257 wxGrid *arg1 = (wxGrid *) 0 ;
16258 int arg2 ;
16259 int arg3 ;
16260 int arg4 ;
16261 int arg5 ;
16262 void *argp1 = 0 ;
16263 int res1 = 0 ;
16264 int val2 ;
16265 int ecode2 = 0 ;
16266 int val3 ;
16267 int ecode3 = 0 ;
16268 int val4 ;
16269 int ecode4 = 0 ;
16270 int val5 ;
16271 int ecode5 = 0 ;
16272 PyObject * obj0 = 0 ;
16273 PyObject * obj1 = 0 ;
16274 PyObject * obj2 = 0 ;
16275 PyObject * obj3 = 0 ;
16276 PyObject * obj4 = 0 ;
16277 char * kwnames[] = {
16278 (char *) "self",(char *) "row",(char *) "col",(char *) "horiz",(char *) "vert", NULL
16279 };
16280
16281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellAlignment",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16283 if (!SWIG_IsOK(res1)) {
16284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellAlignment" "', expected argument " "1"" of type '" "wxGrid *""'");
16285 }
16286 arg1 = reinterpret_cast< wxGrid * >(argp1);
16287 ecode2 = SWIG_AsVal_int(obj1, &val2);
16288 if (!SWIG_IsOK(ecode2)) {
16289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellAlignment" "', expected argument " "2"" of type '" "int""'");
16290 }
16291 arg2 = static_cast< int >(val2);
16292 ecode3 = SWIG_AsVal_int(obj2, &val3);
16293 if (!SWIG_IsOK(ecode3)) {
16294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellAlignment" "', expected argument " "3"" of type '" "int""'");
16295 }
16296 arg3 = static_cast< int >(val3);
16297 ecode4 = SWIG_AsVal_int(obj3, &val4);
16298 if (!SWIG_IsOK(ecode4)) {
16299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellAlignment" "', expected argument " "4"" of type '" "int""'");
16300 }
16301 arg4 = static_cast< int >(val4);
16302 ecode5 = SWIG_AsVal_int(obj4, &val5);
16303 if (!SWIG_IsOK(ecode5)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellAlignment" "', expected argument " "5"" of type '" "int""'");
16305 }
16306 arg5 = static_cast< int >(val5);
16307 {
16308 PyThreadState* __tstate = wxPyBeginAllowThreads();
16309 (arg1)->SetCellAlignment(arg2,arg3,arg4,arg5);
16310 wxPyEndAllowThreads(__tstate);
16311 if (PyErr_Occurred()) SWIG_fail;
16312 }
16313 resultobj = SWIG_Py_Void();
16314 return resultobj;
16315 fail:
16316 return NULL;
16317 }
16318
16319
16320 SWIGINTERN PyObject *_wrap_Grid_SetDefaultCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16321 PyObject *resultobj = 0;
16322 wxGrid *arg1 = (wxGrid *) 0 ;
16323 bool arg2 ;
16324 void *argp1 = 0 ;
16325 int res1 = 0 ;
16326 bool val2 ;
16327 int ecode2 = 0 ;
16328 PyObject * obj0 = 0 ;
16329 PyObject * obj1 = 0 ;
16330 char * kwnames[] = {
16331 (char *) "self",(char *) "allow", NULL
16332 };
16333
16334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultCellOverflow",kwnames,&obj0,&obj1)) SWIG_fail;
16335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16336 if (!SWIG_IsOK(res1)) {
16337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16338 }
16339 arg1 = reinterpret_cast< wxGrid * >(argp1);
16340 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16341 if (!SWIG_IsOK(ecode2)) {
16342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetDefaultCellOverflow" "', expected argument " "2"" of type '" "bool""'");
16343 }
16344 arg2 = static_cast< bool >(val2);
16345 {
16346 PyThreadState* __tstate = wxPyBeginAllowThreads();
16347 (arg1)->SetDefaultCellOverflow(arg2);
16348 wxPyEndAllowThreads(__tstate);
16349 if (PyErr_Occurred()) SWIG_fail;
16350 }
16351 resultobj = SWIG_Py_Void();
16352 return resultobj;
16353 fail:
16354 return NULL;
16355 }
16356
16357
16358 SWIGINTERN PyObject *_wrap_Grid_SetCellOverflow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16359 PyObject *resultobj = 0;
16360 wxGrid *arg1 = (wxGrid *) 0 ;
16361 int arg2 ;
16362 int arg3 ;
16363 bool arg4 ;
16364 void *argp1 = 0 ;
16365 int res1 = 0 ;
16366 int val2 ;
16367 int ecode2 = 0 ;
16368 int val3 ;
16369 int ecode3 = 0 ;
16370 bool val4 ;
16371 int ecode4 = 0 ;
16372 PyObject * obj0 = 0 ;
16373 PyObject * obj1 = 0 ;
16374 PyObject * obj2 = 0 ;
16375 PyObject * obj3 = 0 ;
16376 char * kwnames[] = {
16377 (char *) "self",(char *) "row",(char *) "col",(char *) "allow", NULL
16378 };
16379
16380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellOverflow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellOverflow" "', expected argument " "1"" of type '" "wxGrid *""'");
16384 }
16385 arg1 = reinterpret_cast< wxGrid * >(argp1);
16386 ecode2 = SWIG_AsVal_int(obj1, &val2);
16387 if (!SWIG_IsOK(ecode2)) {
16388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellOverflow" "', expected argument " "2"" of type '" "int""'");
16389 }
16390 arg2 = static_cast< int >(val2);
16391 ecode3 = SWIG_AsVal_int(obj2, &val3);
16392 if (!SWIG_IsOK(ecode3)) {
16393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellOverflow" "', expected argument " "3"" of type '" "int""'");
16394 }
16395 arg3 = static_cast< int >(val3);
16396 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16397 if (!SWIG_IsOK(ecode4)) {
16398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellOverflow" "', expected argument " "4"" of type '" "bool""'");
16399 }
16400 arg4 = static_cast< bool >(val4);
16401 {
16402 PyThreadState* __tstate = wxPyBeginAllowThreads();
16403 (arg1)->SetCellOverflow(arg2,arg3,arg4);
16404 wxPyEndAllowThreads(__tstate);
16405 if (PyErr_Occurred()) SWIG_fail;
16406 }
16407 resultobj = SWIG_Py_Void();
16408 return resultobj;
16409 fail:
16410 return NULL;
16411 }
16412
16413
16414 SWIGINTERN PyObject *_wrap_Grid_SetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16415 PyObject *resultobj = 0;
16416 wxGrid *arg1 = (wxGrid *) 0 ;
16417 int arg2 ;
16418 int arg3 ;
16419 int arg4 ;
16420 int arg5 ;
16421 void *argp1 = 0 ;
16422 int res1 = 0 ;
16423 int val2 ;
16424 int ecode2 = 0 ;
16425 int val3 ;
16426 int ecode3 = 0 ;
16427 int val4 ;
16428 int ecode4 = 0 ;
16429 int val5 ;
16430 int ecode5 = 0 ;
16431 PyObject * obj0 = 0 ;
16432 PyObject * obj1 = 0 ;
16433 PyObject * obj2 = 0 ;
16434 PyObject * obj3 = 0 ;
16435 PyObject * obj4 = 0 ;
16436 char * kwnames[] = {
16437 (char *) "self",(char *) "row",(char *) "col",(char *) "num_rows",(char *) "num_cols", NULL
16438 };
16439
16440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Grid_SetCellSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16442 if (!SWIG_IsOK(res1)) {
16443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellSize" "', expected argument " "1"" of type '" "wxGrid *""'");
16444 }
16445 arg1 = reinterpret_cast< wxGrid * >(argp1);
16446 ecode2 = SWIG_AsVal_int(obj1, &val2);
16447 if (!SWIG_IsOK(ecode2)) {
16448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellSize" "', expected argument " "2"" of type '" "int""'");
16449 }
16450 arg2 = static_cast< int >(val2);
16451 ecode3 = SWIG_AsVal_int(obj2, &val3);
16452 if (!SWIG_IsOK(ecode3)) {
16453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellSize" "', expected argument " "3"" of type '" "int""'");
16454 }
16455 arg3 = static_cast< int >(val3);
16456 ecode4 = SWIG_AsVal_int(obj3, &val4);
16457 if (!SWIG_IsOK(ecode4)) {
16458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetCellSize" "', expected argument " "4"" of type '" "int""'");
16459 }
16460 arg4 = static_cast< int >(val4);
16461 ecode5 = SWIG_AsVal_int(obj4, &val5);
16462 if (!SWIG_IsOK(ecode5)) {
16463 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SetCellSize" "', expected argument " "5"" of type '" "int""'");
16464 }
16465 arg5 = static_cast< int >(val5);
16466 {
16467 PyThreadState* __tstate = wxPyBeginAllowThreads();
16468 (arg1)->SetCellSize(arg2,arg3,arg4,arg5);
16469 wxPyEndAllowThreads(__tstate);
16470 if (PyErr_Occurred()) SWIG_fail;
16471 }
16472 resultobj = SWIG_Py_Void();
16473 return resultobj;
16474 fail:
16475 return NULL;
16476 }
16477
16478
16479 SWIGINTERN PyObject *_wrap_Grid_SetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16480 PyObject *resultobj = 0;
16481 wxGrid *arg1 = (wxGrid *) 0 ;
16482 wxGridCellRenderer *arg2 = (wxGridCellRenderer *) 0 ;
16483 void *argp1 = 0 ;
16484 int res1 = 0 ;
16485 void *argp2 = 0 ;
16486 int res2 = 0 ;
16487 PyObject * obj0 = 0 ;
16488 PyObject * obj1 = 0 ;
16489 char * kwnames[] = {
16490 (char *) "self",(char *) "renderer", NULL
16491 };
16492
16493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultRenderer",kwnames,&obj0,&obj1)) SWIG_fail;
16494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16495 if (!SWIG_IsOK(res1)) {
16496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16497 }
16498 arg1 = reinterpret_cast< wxGrid * >(argp1);
16499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16500 if (!SWIG_IsOK(res2)) {
16501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultRenderer" "', expected argument " "2"" of type '" "wxGridCellRenderer *""'");
16502 }
16503 arg2 = reinterpret_cast< wxGridCellRenderer * >(argp2);
16504 {
16505 PyThreadState* __tstate = wxPyBeginAllowThreads();
16506 (arg1)->SetDefaultRenderer(arg2);
16507 wxPyEndAllowThreads(__tstate);
16508 if (PyErr_Occurred()) SWIG_fail;
16509 }
16510 resultobj = SWIG_Py_Void();
16511 return resultobj;
16512 fail:
16513 return NULL;
16514 }
16515
16516
16517 SWIGINTERN PyObject *_wrap_Grid_SetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj = 0;
16519 wxGrid *arg1 = (wxGrid *) 0 ;
16520 int arg2 ;
16521 int arg3 ;
16522 wxGridCellRenderer *arg4 = (wxGridCellRenderer *) 0 ;
16523 void *argp1 = 0 ;
16524 int res1 = 0 ;
16525 int val2 ;
16526 int ecode2 = 0 ;
16527 int val3 ;
16528 int ecode3 = 0 ;
16529 void *argp4 = 0 ;
16530 int res4 = 0 ;
16531 PyObject * obj0 = 0 ;
16532 PyObject * obj1 = 0 ;
16533 PyObject * obj2 = 0 ;
16534 PyObject * obj3 = 0 ;
16535 char * kwnames[] = {
16536 (char *) "self",(char *) "row",(char *) "col",(char *) "renderer", NULL
16537 };
16538
16539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellRenderer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16541 if (!SWIG_IsOK(res1)) {
16542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16543 }
16544 arg1 = reinterpret_cast< wxGrid * >(argp1);
16545 ecode2 = SWIG_AsVal_int(obj1, &val2);
16546 if (!SWIG_IsOK(ecode2)) {
16547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16548 }
16549 arg2 = static_cast< int >(val2);
16550 ecode3 = SWIG_AsVal_int(obj2, &val3);
16551 if (!SWIG_IsOK(ecode3)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16553 }
16554 arg3 = static_cast< int >(val3);
16555 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
16556 if (!SWIG_IsOK(res4)) {
16557 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellRenderer" "', expected argument " "4"" of type '" "wxGridCellRenderer *""'");
16558 }
16559 arg4 = reinterpret_cast< wxGridCellRenderer * >(argp4);
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 (arg1)->SetCellRenderer(arg2,arg3,arg4);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_Py_Void();
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16574 PyObject *resultobj = 0;
16575 wxGrid *arg1 = (wxGrid *) 0 ;
16576 wxGridCellRenderer *result = 0 ;
16577 void *argp1 = 0 ;
16578 int res1 = 0 ;
16579 PyObject *swig_obj[1] ;
16580
16581 if (!args) SWIG_fail;
16582 swig_obj[0] = args;
16583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16584 if (!SWIG_IsOK(res1)) {
16585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRenderer" "', expected argument " "1"" of type '" "wxGrid const *""'");
16586 }
16587 arg1 = reinterpret_cast< wxGrid * >(argp1);
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRenderer();
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 {
16595 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16596 }
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 SWIGINTERN PyObject *_wrap_Grid_GetCellRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj = 0;
16605 wxGrid *arg1 = (wxGrid *) 0 ;
16606 int arg2 ;
16607 int arg3 ;
16608 wxGridCellRenderer *result = 0 ;
16609 void *argp1 = 0 ;
16610 int res1 = 0 ;
16611 int val2 ;
16612 int ecode2 = 0 ;
16613 int val3 ;
16614 int ecode3 = 0 ;
16615 PyObject * obj0 = 0 ;
16616 PyObject * obj1 = 0 ;
16617 PyObject * obj2 = 0 ;
16618 char * kwnames[] = {
16619 (char *) "self",(char *) "row",(char *) "col", NULL
16620 };
16621
16622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellRenderer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16624 if (!SWIG_IsOK(res1)) {
16625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellRenderer" "', expected argument " "1"" of type '" "wxGrid *""'");
16626 }
16627 arg1 = reinterpret_cast< wxGrid * >(argp1);
16628 ecode2 = SWIG_AsVal_int(obj1, &val2);
16629 if (!SWIG_IsOK(ecode2)) {
16630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellRenderer" "', expected argument " "2"" of type '" "int""'");
16631 }
16632 arg2 = static_cast< int >(val2);
16633 ecode3 = SWIG_AsVal_int(obj2, &val3);
16634 if (!SWIG_IsOK(ecode3)) {
16635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellRenderer" "', expected argument " "3"" of type '" "int""'");
16636 }
16637 arg3 = static_cast< int >(val3);
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 result = (wxGridCellRenderer *)(arg1)->GetCellRenderer(arg2,arg3);
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 {
16645 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
16646 }
16647 return resultobj;
16648 fail:
16649 return NULL;
16650 }
16651
16652
16653 SWIGINTERN PyObject *_wrap_Grid_SetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16654 PyObject *resultobj = 0;
16655 wxGrid *arg1 = (wxGrid *) 0 ;
16656 wxGridCellEditor *arg2 = (wxGridCellEditor *) 0 ;
16657 void *argp1 = 0 ;
16658 int res1 = 0 ;
16659 void *argp2 = 0 ;
16660 int res2 = 0 ;
16661 PyObject * obj0 = 0 ;
16662 PyObject * obj1 = 0 ;
16663 char * kwnames[] = {
16664 (char *) "self",(char *) "editor", NULL
16665 };
16666
16667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetDefaultEditor",kwnames,&obj0,&obj1)) SWIG_fail;
16668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16669 if (!SWIG_IsOK(res1)) {
16670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16671 }
16672 arg1 = reinterpret_cast< wxGrid * >(argp1);
16673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16674 if (!SWIG_IsOK(res2)) {
16675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Grid_SetDefaultEditor" "', expected argument " "2"" of type '" "wxGridCellEditor *""'");
16676 }
16677 arg2 = reinterpret_cast< wxGridCellEditor * >(argp2);
16678 {
16679 PyThreadState* __tstate = wxPyBeginAllowThreads();
16680 (arg1)->SetDefaultEditor(arg2);
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 resultobj = SWIG_Py_Void();
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 SWIGINTERN PyObject *_wrap_Grid_SetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj = 0;
16693 wxGrid *arg1 = (wxGrid *) 0 ;
16694 int arg2 ;
16695 int arg3 ;
16696 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 int val2 ;
16700 int ecode2 = 0 ;
16701 int val3 ;
16702 int ecode3 = 0 ;
16703 void *argp4 = 0 ;
16704 int res4 = 0 ;
16705 PyObject * obj0 = 0 ;
16706 PyObject * obj1 = 0 ;
16707 PyObject * obj2 = 0 ;
16708 PyObject * obj3 = 0 ;
16709 char * kwnames[] = {
16710 (char *) "self",(char *) "row",(char *) "col",(char *) "editor", NULL
16711 };
16712
16713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellEditor",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16715 if (!SWIG_IsOK(res1)) {
16716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16717 }
16718 arg1 = reinterpret_cast< wxGrid * >(argp1);
16719 ecode2 = SWIG_AsVal_int(obj1, &val2);
16720 if (!SWIG_IsOK(ecode2)) {
16721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellEditor" "', expected argument " "2"" of type '" "int""'");
16722 }
16723 arg2 = static_cast< int >(val2);
16724 ecode3 = SWIG_AsVal_int(obj2, &val3);
16725 if (!SWIG_IsOK(ecode3)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellEditor" "', expected argument " "3"" of type '" "int""'");
16727 }
16728 arg3 = static_cast< int >(val3);
16729 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
16730 if (!SWIG_IsOK(res4)) {
16731 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_SetCellEditor" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
16732 }
16733 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 (arg1)->SetCellEditor(arg2,arg3,arg4);
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 resultobj = SWIG_Py_Void();
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16748 PyObject *resultobj = 0;
16749 wxGrid *arg1 = (wxGrid *) 0 ;
16750 wxGridCellEditor *result = 0 ;
16751 void *argp1 = 0 ;
16752 int res1 = 0 ;
16753 PyObject *swig_obj[1] ;
16754
16755 if (!args) SWIG_fail;
16756 swig_obj[0] = args;
16757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditor" "', expected argument " "1"" of type '" "wxGrid const *""'");
16760 }
16761 arg1 = reinterpret_cast< wxGrid * >(argp1);
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditor();
16765 wxPyEndAllowThreads(__tstate);
16766 if (PyErr_Occurred()) SWIG_fail;
16767 }
16768 {
16769 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16770 }
16771 return resultobj;
16772 fail:
16773 return NULL;
16774 }
16775
16776
16777 SWIGINTERN PyObject *_wrap_Grid_GetCellEditor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16778 PyObject *resultobj = 0;
16779 wxGrid *arg1 = (wxGrid *) 0 ;
16780 int arg2 ;
16781 int arg3 ;
16782 wxGridCellEditor *result = 0 ;
16783 void *argp1 = 0 ;
16784 int res1 = 0 ;
16785 int val2 ;
16786 int ecode2 = 0 ;
16787 int val3 ;
16788 int ecode3 = 0 ;
16789 PyObject * obj0 = 0 ;
16790 PyObject * obj1 = 0 ;
16791 PyObject * obj2 = 0 ;
16792 char * kwnames[] = {
16793 (char *) "self",(char *) "row",(char *) "col", NULL
16794 };
16795
16796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellEditor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16798 if (!SWIG_IsOK(res1)) {
16799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellEditor" "', expected argument " "1"" of type '" "wxGrid *""'");
16800 }
16801 arg1 = reinterpret_cast< wxGrid * >(argp1);
16802 ecode2 = SWIG_AsVal_int(obj1, &val2);
16803 if (!SWIG_IsOK(ecode2)) {
16804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellEditor" "', expected argument " "2"" of type '" "int""'");
16805 }
16806 arg2 = static_cast< int >(val2);
16807 ecode3 = SWIG_AsVal_int(obj2, &val3);
16808 if (!SWIG_IsOK(ecode3)) {
16809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellEditor" "', expected argument " "3"" of type '" "int""'");
16810 }
16811 arg3 = static_cast< int >(val3);
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 result = (wxGridCellEditor *)(arg1)->GetCellEditor(arg2,arg3);
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 {
16819 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
16820 }
16821 return resultobj;
16822 fail:
16823 return NULL;
16824 }
16825
16826
16827 SWIGINTERN PyObject *_wrap_Grid_GetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16828 PyObject *resultobj = 0;
16829 wxGrid *arg1 = (wxGrid *) 0 ;
16830 int arg2 ;
16831 int arg3 ;
16832 wxString result;
16833 void *argp1 = 0 ;
16834 int res1 = 0 ;
16835 int val2 ;
16836 int ecode2 = 0 ;
16837 int val3 ;
16838 int ecode3 = 0 ;
16839 PyObject * obj0 = 0 ;
16840 PyObject * obj1 = 0 ;
16841 PyObject * obj2 = 0 ;
16842 char * kwnames[] = {
16843 (char *) "self",(char *) "row",(char *) "col", NULL
16844 };
16845
16846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetCellValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16848 if (!SWIG_IsOK(res1)) {
16849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
16850 }
16851 arg1 = reinterpret_cast< wxGrid * >(argp1);
16852 ecode2 = SWIG_AsVal_int(obj1, &val2);
16853 if (!SWIG_IsOK(ecode2)) {
16854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetCellValue" "', expected argument " "2"" of type '" "int""'");
16855 }
16856 arg2 = static_cast< int >(val2);
16857 ecode3 = SWIG_AsVal_int(obj2, &val3);
16858 if (!SWIG_IsOK(ecode3)) {
16859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetCellValue" "', expected argument " "3"" of type '" "int""'");
16860 }
16861 arg3 = static_cast< int >(val3);
16862 {
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 result = (arg1)->GetCellValue(arg2,arg3);
16865 wxPyEndAllowThreads(__tstate);
16866 if (PyErr_Occurred()) SWIG_fail;
16867 }
16868 {
16869 #if wxUSE_UNICODE
16870 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16871 #else
16872 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16873 #endif
16874 }
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 SWIGINTERN PyObject *_wrap_Grid_SetCellValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16882 PyObject *resultobj = 0;
16883 wxGrid *arg1 = (wxGrid *) 0 ;
16884 int arg2 ;
16885 int arg3 ;
16886 wxString *arg4 = 0 ;
16887 void *argp1 = 0 ;
16888 int res1 = 0 ;
16889 int val2 ;
16890 int ecode2 = 0 ;
16891 int val3 ;
16892 int ecode3 = 0 ;
16893 bool temp4 = false ;
16894 PyObject * obj0 = 0 ;
16895 PyObject * obj1 = 0 ;
16896 PyObject * obj2 = 0 ;
16897 PyObject * obj3 = 0 ;
16898 char * kwnames[] = {
16899 (char *) "self",(char *) "row",(char *) "col",(char *) "s", NULL
16900 };
16901
16902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_SetCellValue",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16904 if (!SWIG_IsOK(res1)) {
16905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetCellValue" "', expected argument " "1"" of type '" "wxGrid *""'");
16906 }
16907 arg1 = reinterpret_cast< wxGrid * >(argp1);
16908 ecode2 = SWIG_AsVal_int(obj1, &val2);
16909 if (!SWIG_IsOK(ecode2)) {
16910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetCellValue" "', expected argument " "2"" of type '" "int""'");
16911 }
16912 arg2 = static_cast< int >(val2);
16913 ecode3 = SWIG_AsVal_int(obj2, &val3);
16914 if (!SWIG_IsOK(ecode3)) {
16915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetCellValue" "', expected argument " "3"" of type '" "int""'");
16916 }
16917 arg3 = static_cast< int >(val3);
16918 {
16919 arg4 = wxString_in_helper(obj3);
16920 if (arg4 == NULL) SWIG_fail;
16921 temp4 = true;
16922 }
16923 {
16924 PyThreadState* __tstate = wxPyBeginAllowThreads();
16925 (arg1)->SetCellValue(arg2,arg3,(wxString const &)*arg4);
16926 wxPyEndAllowThreads(__tstate);
16927 if (PyErr_Occurred()) SWIG_fail;
16928 }
16929 resultobj = SWIG_Py_Void();
16930 {
16931 if (temp4)
16932 delete arg4;
16933 }
16934 return resultobj;
16935 fail:
16936 {
16937 if (temp4)
16938 delete arg4;
16939 }
16940 return NULL;
16941 }
16942
16943
16944 SWIGINTERN PyObject *_wrap_Grid_IsReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16945 PyObject *resultobj = 0;
16946 wxGrid *arg1 = (wxGrid *) 0 ;
16947 int arg2 ;
16948 int arg3 ;
16949 bool result;
16950 void *argp1 = 0 ;
16951 int res1 = 0 ;
16952 int val2 ;
16953 int ecode2 = 0 ;
16954 int val3 ;
16955 int ecode3 = 0 ;
16956 PyObject * obj0 = 0 ;
16957 PyObject * obj1 = 0 ;
16958 PyObject * obj2 = 0 ;
16959 char * kwnames[] = {
16960 (char *) "self",(char *) "row",(char *) "col", NULL
16961 };
16962
16963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsReadOnly",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
16965 if (!SWIG_IsOK(res1)) {
16966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsReadOnly" "', expected argument " "1"" of type '" "wxGrid const *""'");
16967 }
16968 arg1 = reinterpret_cast< wxGrid * >(argp1);
16969 ecode2 = SWIG_AsVal_int(obj1, &val2);
16970 if (!SWIG_IsOK(ecode2)) {
16971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsReadOnly" "', expected argument " "2"" of type '" "int""'");
16972 }
16973 arg2 = static_cast< int >(val2);
16974 ecode3 = SWIG_AsVal_int(obj2, &val3);
16975 if (!SWIG_IsOK(ecode3)) {
16976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsReadOnly" "', expected argument " "3"" of type '" "int""'");
16977 }
16978 arg3 = static_cast< int >(val3);
16979 {
16980 PyThreadState* __tstate = wxPyBeginAllowThreads();
16981 result = (bool)((wxGrid const *)arg1)->IsReadOnly(arg2,arg3);
16982 wxPyEndAllowThreads(__tstate);
16983 if (PyErr_Occurred()) SWIG_fail;
16984 }
16985 {
16986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16987 }
16988 return resultobj;
16989 fail:
16990 return NULL;
16991 }
16992
16993
16994 SWIGINTERN PyObject *_wrap_Grid_SetReadOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16995 PyObject *resultobj = 0;
16996 wxGrid *arg1 = (wxGrid *) 0 ;
16997 int arg2 ;
16998 int arg3 ;
16999 bool arg4 = (bool) true ;
17000 void *argp1 = 0 ;
17001 int res1 = 0 ;
17002 int val2 ;
17003 int ecode2 = 0 ;
17004 int val3 ;
17005 int ecode3 = 0 ;
17006 bool val4 ;
17007 int ecode4 = 0 ;
17008 PyObject * obj0 = 0 ;
17009 PyObject * obj1 = 0 ;
17010 PyObject * obj2 = 0 ;
17011 PyObject * obj3 = 0 ;
17012 char * kwnames[] = {
17013 (char *) "self",(char *) "row",(char *) "col",(char *) "isReadOnly", NULL
17014 };
17015
17016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Grid_SetReadOnly",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17018 if (!SWIG_IsOK(res1)) {
17019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetReadOnly" "', expected argument " "1"" of type '" "wxGrid *""'");
17020 }
17021 arg1 = reinterpret_cast< wxGrid * >(argp1);
17022 ecode2 = SWIG_AsVal_int(obj1, &val2);
17023 if (!SWIG_IsOK(ecode2)) {
17024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetReadOnly" "', expected argument " "2"" of type '" "int""'");
17025 }
17026 arg2 = static_cast< int >(val2);
17027 ecode3 = SWIG_AsVal_int(obj2, &val3);
17028 if (!SWIG_IsOK(ecode3)) {
17029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetReadOnly" "', expected argument " "3"" of type '" "int""'");
17030 }
17031 arg3 = static_cast< int >(val3);
17032 if (obj3) {
17033 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17034 if (!SWIG_IsOK(ecode4)) {
17035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SetReadOnly" "', expected argument " "4"" of type '" "bool""'");
17036 }
17037 arg4 = static_cast< bool >(val4);
17038 }
17039 {
17040 PyThreadState* __tstate = wxPyBeginAllowThreads();
17041 (arg1)->SetReadOnly(arg2,arg3,arg4);
17042 wxPyEndAllowThreads(__tstate);
17043 if (PyErr_Occurred()) SWIG_fail;
17044 }
17045 resultobj = SWIG_Py_Void();
17046 return resultobj;
17047 fail:
17048 return NULL;
17049 }
17050
17051
17052 SWIGINTERN PyObject *_wrap_Grid_SelectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17053 PyObject *resultobj = 0;
17054 wxGrid *arg1 = (wxGrid *) 0 ;
17055 int arg2 ;
17056 bool arg3 = (bool) false ;
17057 void *argp1 = 0 ;
17058 int res1 = 0 ;
17059 int val2 ;
17060 int ecode2 = 0 ;
17061 bool val3 ;
17062 int ecode3 = 0 ;
17063 PyObject * obj0 = 0 ;
17064 PyObject * obj1 = 0 ;
17065 PyObject * obj2 = 0 ;
17066 char * kwnames[] = {
17067 (char *) "self",(char *) "row",(char *) "addToSelected", NULL
17068 };
17069
17070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17072 if (!SWIG_IsOK(res1)) {
17073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17074 }
17075 arg1 = reinterpret_cast< wxGrid * >(argp1);
17076 ecode2 = SWIG_AsVal_int(obj1, &val2);
17077 if (!SWIG_IsOK(ecode2)) {
17078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectRow" "', expected argument " "2"" of type '" "int""'");
17079 }
17080 arg2 = static_cast< int >(val2);
17081 if (obj2) {
17082 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17083 if (!SWIG_IsOK(ecode3)) {
17084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectRow" "', expected argument " "3"" of type '" "bool""'");
17085 }
17086 arg3 = static_cast< bool >(val3);
17087 }
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 (arg1)->SelectRow(arg2,arg3);
17091 wxPyEndAllowThreads(__tstate);
17092 if (PyErr_Occurred()) SWIG_fail;
17093 }
17094 resultobj = SWIG_Py_Void();
17095 return resultobj;
17096 fail:
17097 return NULL;
17098 }
17099
17100
17101 SWIGINTERN PyObject *_wrap_Grid_SelectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17102 PyObject *resultobj = 0;
17103 wxGrid *arg1 = (wxGrid *) 0 ;
17104 int arg2 ;
17105 bool arg3 = (bool) false ;
17106 void *argp1 = 0 ;
17107 int res1 = 0 ;
17108 int val2 ;
17109 int ecode2 = 0 ;
17110 bool val3 ;
17111 int ecode3 = 0 ;
17112 PyObject * obj0 = 0 ;
17113 PyObject * obj1 = 0 ;
17114 PyObject * obj2 = 0 ;
17115 char * kwnames[] = {
17116 (char *) "self",(char *) "col",(char *) "addToSelected", NULL
17117 };
17118
17119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Grid_SelectCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17121 if (!SWIG_IsOK(res1)) {
17122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17123 }
17124 arg1 = reinterpret_cast< wxGrid * >(argp1);
17125 ecode2 = SWIG_AsVal_int(obj1, &val2);
17126 if (!SWIG_IsOK(ecode2)) {
17127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectCol" "', expected argument " "2"" of type '" "int""'");
17128 }
17129 arg2 = static_cast< int >(val2);
17130 if (obj2) {
17131 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17132 if (!SWIG_IsOK(ecode3)) {
17133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectCol" "', expected argument " "3"" of type '" "bool""'");
17134 }
17135 arg3 = static_cast< bool >(val3);
17136 }
17137 {
17138 PyThreadState* __tstate = wxPyBeginAllowThreads();
17139 (arg1)->SelectCol(arg2,arg3);
17140 wxPyEndAllowThreads(__tstate);
17141 if (PyErr_Occurred()) SWIG_fail;
17142 }
17143 resultobj = SWIG_Py_Void();
17144 return resultobj;
17145 fail:
17146 return NULL;
17147 }
17148
17149
17150 SWIGINTERN PyObject *_wrap_Grid_SelectBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj = 0;
17152 wxGrid *arg1 = (wxGrid *) 0 ;
17153 int arg2 ;
17154 int arg3 ;
17155 int arg4 ;
17156 int arg5 ;
17157 bool arg6 = (bool) false ;
17158 void *argp1 = 0 ;
17159 int res1 = 0 ;
17160 int val2 ;
17161 int ecode2 = 0 ;
17162 int val3 ;
17163 int ecode3 = 0 ;
17164 int val4 ;
17165 int ecode4 = 0 ;
17166 int val5 ;
17167 int ecode5 = 0 ;
17168 bool val6 ;
17169 int ecode6 = 0 ;
17170 PyObject * obj0 = 0 ;
17171 PyObject * obj1 = 0 ;
17172 PyObject * obj2 = 0 ;
17173 PyObject * obj3 = 0 ;
17174 PyObject * obj4 = 0 ;
17175 PyObject * obj5 = 0 ;
17176 char * kwnames[] = {
17177 (char *) "self",(char *) "topRow",(char *) "leftCol",(char *) "bottomRow",(char *) "rightCol",(char *) "addToSelected", NULL
17178 };
17179
17180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Grid_SelectBlock",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17182 if (!SWIG_IsOK(res1)) {
17183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectBlock" "', expected argument " "1"" of type '" "wxGrid *""'");
17184 }
17185 arg1 = reinterpret_cast< wxGrid * >(argp1);
17186 ecode2 = SWIG_AsVal_int(obj1, &val2);
17187 if (!SWIG_IsOK(ecode2)) {
17188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SelectBlock" "', expected argument " "2"" of type '" "int""'");
17189 }
17190 arg2 = static_cast< int >(val2);
17191 ecode3 = SWIG_AsVal_int(obj2, &val3);
17192 if (!SWIG_IsOK(ecode3)) {
17193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SelectBlock" "', expected argument " "3"" of type '" "int""'");
17194 }
17195 arg3 = static_cast< int >(val3);
17196 ecode4 = SWIG_AsVal_int(obj3, &val4);
17197 if (!SWIG_IsOK(ecode4)) {
17198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Grid_SelectBlock" "', expected argument " "4"" of type '" "int""'");
17199 }
17200 arg4 = static_cast< int >(val4);
17201 ecode5 = SWIG_AsVal_int(obj4, &val5);
17202 if (!SWIG_IsOK(ecode5)) {
17203 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Grid_SelectBlock" "', expected argument " "5"" of type '" "int""'");
17204 }
17205 arg5 = static_cast< int >(val5);
17206 if (obj5) {
17207 ecode6 = SWIG_AsVal_bool(obj5, &val6);
17208 if (!SWIG_IsOK(ecode6)) {
17209 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Grid_SelectBlock" "', expected argument " "6"" of type '" "bool""'");
17210 }
17211 arg6 = static_cast< bool >(val6);
17212 }
17213 {
17214 PyThreadState* __tstate = wxPyBeginAllowThreads();
17215 (arg1)->SelectBlock(arg2,arg3,arg4,arg5,arg6);
17216 wxPyEndAllowThreads(__tstate);
17217 if (PyErr_Occurred()) SWIG_fail;
17218 }
17219 resultobj = SWIG_Py_Void();
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 SWIGINTERN PyObject *_wrap_Grid_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17227 PyObject *resultobj = 0;
17228 wxGrid *arg1 = (wxGrid *) 0 ;
17229 void *argp1 = 0 ;
17230 int res1 = 0 ;
17231 PyObject *swig_obj[1] ;
17232
17233 if (!args) SWIG_fail;
17234 swig_obj[0] = args;
17235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17236 if (!SWIG_IsOK(res1)) {
17237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SelectAll" "', expected argument " "1"" of type '" "wxGrid *""'");
17238 }
17239 arg1 = reinterpret_cast< wxGrid * >(argp1);
17240 {
17241 PyThreadState* __tstate = wxPyBeginAllowThreads();
17242 (arg1)->SelectAll();
17243 wxPyEndAllowThreads(__tstate);
17244 if (PyErr_Occurred()) SWIG_fail;
17245 }
17246 resultobj = SWIG_Py_Void();
17247 return resultobj;
17248 fail:
17249 return NULL;
17250 }
17251
17252
17253 SWIGINTERN PyObject *_wrap_Grid_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17254 PyObject *resultobj = 0;
17255 wxGrid *arg1 = (wxGrid *) 0 ;
17256 bool result;
17257 void *argp1 = 0 ;
17258 int res1 = 0 ;
17259 PyObject *swig_obj[1] ;
17260
17261 if (!args) SWIG_fail;
17262 swig_obj[0] = args;
17263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17264 if (!SWIG_IsOK(res1)) {
17265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17266 }
17267 arg1 = reinterpret_cast< wxGrid * >(argp1);
17268 {
17269 PyThreadState* __tstate = wxPyBeginAllowThreads();
17270 result = (bool)(arg1)->IsSelection();
17271 wxPyEndAllowThreads(__tstate);
17272 if (PyErr_Occurred()) SWIG_fail;
17273 }
17274 {
17275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17276 }
17277 return resultobj;
17278 fail:
17279 return NULL;
17280 }
17281
17282
17283 SWIGINTERN PyObject *_wrap_Grid_ClearSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17284 PyObject *resultobj = 0;
17285 wxGrid *arg1 = (wxGrid *) 0 ;
17286 void *argp1 = 0 ;
17287 int res1 = 0 ;
17288 PyObject *swig_obj[1] ;
17289
17290 if (!args) SWIG_fail;
17291 swig_obj[0] = args;
17292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17293 if (!SWIG_IsOK(res1)) {
17294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_ClearSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17295 }
17296 arg1 = reinterpret_cast< wxGrid * >(argp1);
17297 {
17298 PyThreadState* __tstate = wxPyBeginAllowThreads();
17299 (arg1)->ClearSelection();
17300 wxPyEndAllowThreads(__tstate);
17301 if (PyErr_Occurred()) SWIG_fail;
17302 }
17303 resultobj = SWIG_Py_Void();
17304 return resultobj;
17305 fail:
17306 return NULL;
17307 }
17308
17309
17310 SWIGINTERN PyObject *_wrap_Grid_IsInSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17311 PyObject *resultobj = 0;
17312 wxGrid *arg1 = (wxGrid *) 0 ;
17313 int arg2 ;
17314 int arg3 ;
17315 bool result;
17316 void *argp1 = 0 ;
17317 int res1 = 0 ;
17318 int val2 ;
17319 int ecode2 = 0 ;
17320 int val3 ;
17321 int ecode3 = 0 ;
17322 PyObject * obj0 = 0 ;
17323 PyObject * obj1 = 0 ;
17324 PyObject * obj2 = 0 ;
17325 char * kwnames[] = {
17326 (char *) "self",(char *) "row",(char *) "col", NULL
17327 };
17328
17329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_IsInSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17331 if (!SWIG_IsOK(res1)) {
17332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_IsInSelection" "', expected argument " "1"" of type '" "wxGrid *""'");
17333 }
17334 arg1 = reinterpret_cast< wxGrid * >(argp1);
17335 ecode2 = SWIG_AsVal_int(obj1, &val2);
17336 if (!SWIG_IsOK(ecode2)) {
17337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_IsInSelection" "', expected argument " "2"" of type '" "int""'");
17338 }
17339 arg2 = static_cast< int >(val2);
17340 ecode3 = SWIG_AsVal_int(obj2, &val3);
17341 if (!SWIG_IsOK(ecode3)) {
17342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_IsInSelection" "', expected argument " "3"" of type '" "int""'");
17343 }
17344 arg3 = static_cast< int >(val3);
17345 {
17346 PyThreadState* __tstate = wxPyBeginAllowThreads();
17347 result = (bool)(arg1)->IsInSelection(arg2,arg3);
17348 wxPyEndAllowThreads(__tstate);
17349 if (PyErr_Occurred()) SWIG_fail;
17350 }
17351 {
17352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17353 }
17354 return resultobj;
17355 fail:
17356 return NULL;
17357 }
17358
17359
17360 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCells(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17361 PyObject *resultobj = 0;
17362 wxGrid *arg1 = (wxGrid *) 0 ;
17363 wxGridCellCoordsArray result;
17364 void *argp1 = 0 ;
17365 int res1 = 0 ;
17366 PyObject *swig_obj[1] ;
17367
17368 if (!args) SWIG_fail;
17369 swig_obj[0] = args;
17370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17371 if (!SWIG_IsOK(res1)) {
17372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCells" "', expected argument " "1"" of type '" "wxGrid const *""'");
17373 }
17374 arg1 = reinterpret_cast< wxGrid * >(argp1);
17375 {
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = ((wxGrid const *)arg1)->GetSelectedCells();
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 {
17382 resultobj = wxGridCellCoordsArray_helper(result);
17383 }
17384 return resultobj;
17385 fail:
17386 return NULL;
17387 }
17388
17389
17390 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17391 PyObject *resultobj = 0;
17392 wxGrid *arg1 = (wxGrid *) 0 ;
17393 wxGridCellCoordsArray result;
17394 void *argp1 = 0 ;
17395 int res1 = 0 ;
17396 PyObject *swig_obj[1] ;
17397
17398 if (!args) SWIG_fail;
17399 swig_obj[0] = args;
17400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17401 if (!SWIG_IsOK(res1)) {
17402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockTopLeft" "', expected argument " "1"" of type '" "wxGrid const *""'");
17403 }
17404 arg1 = reinterpret_cast< wxGrid * >(argp1);
17405 {
17406 PyThreadState* __tstate = wxPyBeginAllowThreads();
17407 result = ((wxGrid const *)arg1)->GetSelectionBlockTopLeft();
17408 wxPyEndAllowThreads(__tstate);
17409 if (PyErr_Occurred()) SWIG_fail;
17410 }
17411 {
17412 resultobj = wxGridCellCoordsArray_helper(result);
17413 }
17414 return resultobj;
17415 fail:
17416 return NULL;
17417 }
17418
17419
17420 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBlockBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17421 PyObject *resultobj = 0;
17422 wxGrid *arg1 = (wxGrid *) 0 ;
17423 wxGridCellCoordsArray result;
17424 void *argp1 = 0 ;
17425 int res1 = 0 ;
17426 PyObject *swig_obj[1] ;
17427
17428 if (!args) SWIG_fail;
17429 swig_obj[0] = args;
17430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17431 if (!SWIG_IsOK(res1)) {
17432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBlockBottomRight" "', expected argument " "1"" of type '" "wxGrid const *""'");
17433 }
17434 arg1 = reinterpret_cast< wxGrid * >(argp1);
17435 {
17436 PyThreadState* __tstate = wxPyBeginAllowThreads();
17437 result = ((wxGrid const *)arg1)->GetSelectionBlockBottomRight();
17438 wxPyEndAllowThreads(__tstate);
17439 if (PyErr_Occurred()) SWIG_fail;
17440 }
17441 {
17442 resultobj = wxGridCellCoordsArray_helper(result);
17443 }
17444 return resultobj;
17445 fail:
17446 return NULL;
17447 }
17448
17449
17450 SWIGINTERN PyObject *_wrap_Grid_GetSelectedRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17451 PyObject *resultobj = 0;
17452 wxGrid *arg1 = (wxGrid *) 0 ;
17453 wxArrayInt result;
17454 void *argp1 = 0 ;
17455 int res1 = 0 ;
17456 PyObject *swig_obj[1] ;
17457
17458 if (!args) SWIG_fail;
17459 swig_obj[0] = args;
17460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17461 if (!SWIG_IsOK(res1)) {
17462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedRows" "', expected argument " "1"" of type '" "wxGrid const *""'");
17463 }
17464 arg1 = reinterpret_cast< wxGrid * >(argp1);
17465 {
17466 PyThreadState* __tstate = wxPyBeginAllowThreads();
17467 result = ((wxGrid const *)arg1)->GetSelectedRows();
17468 wxPyEndAllowThreads(__tstate);
17469 if (PyErr_Occurred()) SWIG_fail;
17470 }
17471 {
17472 resultobj = PyList_New(0);
17473 size_t idx;
17474 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17475 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17476 PyList_Append(resultobj, val);
17477 Py_DECREF(val);
17478 }
17479 }
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 SWIGINTERN PyObject *_wrap_Grid_GetSelectedCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 PyObject *resultobj = 0;
17488 wxGrid *arg1 = (wxGrid *) 0 ;
17489 wxArrayInt result;
17490 void *argp1 = 0 ;
17491 int res1 = 0 ;
17492 PyObject *swig_obj[1] ;
17493
17494 if (!args) SWIG_fail;
17495 swig_obj[0] = args;
17496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17497 if (!SWIG_IsOK(res1)) {
17498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectedCols" "', expected argument " "1"" of type '" "wxGrid const *""'");
17499 }
17500 arg1 = reinterpret_cast< wxGrid * >(argp1);
17501 {
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 result = ((wxGrid const *)arg1)->GetSelectedCols();
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 {
17508 resultobj = PyList_New(0);
17509 size_t idx;
17510 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
17511 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
17512 PyList_Append(resultobj, val);
17513 Py_DECREF(val);
17514 }
17515 }
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 SWIGINTERN PyObject *_wrap_Grid_DeselectRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17523 PyObject *resultobj = 0;
17524 wxGrid *arg1 = (wxGrid *) 0 ;
17525 int arg2 ;
17526 void *argp1 = 0 ;
17527 int res1 = 0 ;
17528 int val2 ;
17529 int ecode2 = 0 ;
17530 PyObject * obj0 = 0 ;
17531 PyObject * obj1 = 0 ;
17532 char * kwnames[] = {
17533 (char *) "self",(char *) "row", NULL
17534 };
17535
17536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectRow",kwnames,&obj0,&obj1)) SWIG_fail;
17537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17538 if (!SWIG_IsOK(res1)) {
17539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectRow" "', expected argument " "1"" of type '" "wxGrid *""'");
17540 }
17541 arg1 = reinterpret_cast< wxGrid * >(argp1);
17542 ecode2 = SWIG_AsVal_int(obj1, &val2);
17543 if (!SWIG_IsOK(ecode2)) {
17544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectRow" "', expected argument " "2"" of type '" "int""'");
17545 }
17546 arg2 = static_cast< int >(val2);
17547 {
17548 PyThreadState* __tstate = wxPyBeginAllowThreads();
17549 (arg1)->DeselectRow(arg2);
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 resultobj = SWIG_Py_Void();
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 SWIGINTERN PyObject *_wrap_Grid_DeselectCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17561 PyObject *resultobj = 0;
17562 wxGrid *arg1 = (wxGrid *) 0 ;
17563 int arg2 ;
17564 void *argp1 = 0 ;
17565 int res1 = 0 ;
17566 int val2 ;
17567 int ecode2 = 0 ;
17568 PyObject * obj0 = 0 ;
17569 PyObject * obj1 = 0 ;
17570 char * kwnames[] = {
17571 (char *) "self",(char *) "col", NULL
17572 };
17573
17574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_DeselectCol",kwnames,&obj0,&obj1)) SWIG_fail;
17575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17576 if (!SWIG_IsOK(res1)) {
17577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCol" "', expected argument " "1"" of type '" "wxGrid *""'");
17578 }
17579 arg1 = reinterpret_cast< wxGrid * >(argp1);
17580 ecode2 = SWIG_AsVal_int(obj1, &val2);
17581 if (!SWIG_IsOK(ecode2)) {
17582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCol" "', expected argument " "2"" of type '" "int""'");
17583 }
17584 arg2 = static_cast< int >(val2);
17585 {
17586 PyThreadState* __tstate = wxPyBeginAllowThreads();
17587 (arg1)->DeselectCol(arg2);
17588 wxPyEndAllowThreads(__tstate);
17589 if (PyErr_Occurred()) SWIG_fail;
17590 }
17591 resultobj = SWIG_Py_Void();
17592 return resultobj;
17593 fail:
17594 return NULL;
17595 }
17596
17597
17598 SWIGINTERN PyObject *_wrap_Grid_DeselectCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17599 PyObject *resultobj = 0;
17600 wxGrid *arg1 = (wxGrid *) 0 ;
17601 int arg2 ;
17602 int arg3 ;
17603 void *argp1 = 0 ;
17604 int res1 = 0 ;
17605 int val2 ;
17606 int ecode2 = 0 ;
17607 int val3 ;
17608 int ecode3 = 0 ;
17609 PyObject * obj0 = 0 ;
17610 PyObject * obj1 = 0 ;
17611 PyObject * obj2 = 0 ;
17612 char * kwnames[] = {
17613 (char *) "self",(char *) "row",(char *) "col", NULL
17614 };
17615
17616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_DeselectCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17618 if (!SWIG_IsOK(res1)) {
17619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_DeselectCell" "', expected argument " "1"" of type '" "wxGrid *""'");
17620 }
17621 arg1 = reinterpret_cast< wxGrid * >(argp1);
17622 ecode2 = SWIG_AsVal_int(obj1, &val2);
17623 if (!SWIG_IsOK(ecode2)) {
17624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_DeselectCell" "', expected argument " "2"" of type '" "int""'");
17625 }
17626 arg2 = static_cast< int >(val2);
17627 ecode3 = SWIG_AsVal_int(obj2, &val3);
17628 if (!SWIG_IsOK(ecode3)) {
17629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_DeselectCell" "', expected argument " "3"" of type '" "int""'");
17630 }
17631 arg3 = static_cast< int >(val3);
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 (arg1)->DeselectCell(arg2,arg3);
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 resultobj = SWIG_Py_Void();
17639 return resultobj;
17640 fail:
17641 return NULL;
17642 }
17643
17644
17645 SWIGINTERN PyObject *_wrap_Grid_BlockToDeviceRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17646 PyObject *resultobj = 0;
17647 wxGrid *arg1 = (wxGrid *) 0 ;
17648 wxGridCellCoords *arg2 = 0 ;
17649 wxGridCellCoords *arg3 = 0 ;
17650 wxRect result;
17651 void *argp1 = 0 ;
17652 int res1 = 0 ;
17653 wxGridCellCoords temp2 ;
17654 wxGridCellCoords temp3 ;
17655 PyObject * obj0 = 0 ;
17656 PyObject * obj1 = 0 ;
17657 PyObject * obj2 = 0 ;
17658 char * kwnames[] = {
17659 (char *) "self",(char *) "topLeft",(char *) "bottomRight", NULL
17660 };
17661
17662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_BlockToDeviceRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17664 if (!SWIG_IsOK(res1)) {
17665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_BlockToDeviceRect" "', expected argument " "1"" of type '" "wxGrid *""'");
17666 }
17667 arg1 = reinterpret_cast< wxGrid * >(argp1);
17668 {
17669 arg2 = &temp2;
17670 if (! wxGridCellCoords_helper(obj1, &arg2)) SWIG_fail;
17671 }
17672 {
17673 arg3 = &temp3;
17674 if (! wxGridCellCoords_helper(obj2, &arg3)) SWIG_fail;
17675 }
17676 {
17677 PyThreadState* __tstate = wxPyBeginAllowThreads();
17678 result = (arg1)->BlockToDeviceRect((wxGridCellCoords const &)*arg2,(wxGridCellCoords const &)*arg3);
17679 wxPyEndAllowThreads(__tstate);
17680 if (PyErr_Occurred()) SWIG_fail;
17681 }
17682 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
17683 return resultobj;
17684 fail:
17685 return NULL;
17686 }
17687
17688
17689 SWIGINTERN PyObject *_wrap_Grid_GetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 PyObject *resultobj = 0;
17691 wxGrid *arg1 = (wxGrid *) 0 ;
17692 wxColour result;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 PyObject *swig_obj[1] ;
17696
17697 if (!args) SWIG_fail;
17698 swig_obj[0] = args;
17699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17700 if (!SWIG_IsOK(res1)) {
17701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17702 }
17703 arg1 = reinterpret_cast< wxGrid * >(argp1);
17704 {
17705 PyThreadState* __tstate = wxPyBeginAllowThreads();
17706 result = ((wxGrid const *)arg1)->GetSelectionBackground();
17707 wxPyEndAllowThreads(__tstate);
17708 if (PyErr_Occurred()) SWIG_fail;
17709 }
17710 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17711 return resultobj;
17712 fail:
17713 return NULL;
17714 }
17715
17716
17717 SWIGINTERN PyObject *_wrap_Grid_GetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17718 PyObject *resultobj = 0;
17719 wxGrid *arg1 = (wxGrid *) 0 ;
17720 wxColour result;
17721 void *argp1 = 0 ;
17722 int res1 = 0 ;
17723 PyObject *swig_obj[1] ;
17724
17725 if (!args) SWIG_fail;
17726 swig_obj[0] = args;
17727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17728 if (!SWIG_IsOK(res1)) {
17729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid const *""'");
17730 }
17731 arg1 = reinterpret_cast< wxGrid * >(argp1);
17732 {
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 result = ((wxGrid const *)arg1)->GetSelectionForeground();
17735 wxPyEndAllowThreads(__tstate);
17736 if (PyErr_Occurred()) SWIG_fail;
17737 }
17738 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 SWIGINTERN PyObject *_wrap_Grid_SetSelectionBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17746 PyObject *resultobj = 0;
17747 wxGrid *arg1 = (wxGrid *) 0 ;
17748 wxColour *arg2 = 0 ;
17749 void *argp1 = 0 ;
17750 int res1 = 0 ;
17751 wxColour temp2 ;
17752 PyObject * obj0 = 0 ;
17753 PyObject * obj1 = 0 ;
17754 char * kwnames[] = {
17755 (char *) "self",(char *) "c", NULL
17756 };
17757
17758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionBackground",kwnames,&obj0,&obj1)) SWIG_fail;
17759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17760 if (!SWIG_IsOK(res1)) {
17761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionBackground" "', expected argument " "1"" of type '" "wxGrid *""'");
17762 }
17763 arg1 = reinterpret_cast< wxGrid * >(argp1);
17764 {
17765 arg2 = &temp2;
17766 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
17767 }
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 (arg1)->SetSelectionBackground((wxColour const &)*arg2);
17771 wxPyEndAllowThreads(__tstate);
17772 if (PyErr_Occurred()) SWIG_fail;
17773 }
17774 resultobj = SWIG_Py_Void();
17775 return resultobj;
17776 fail:
17777 return NULL;
17778 }
17779
17780
17781 SWIGINTERN PyObject *_wrap_Grid_SetSelectionForeground(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17782 PyObject *resultobj = 0;
17783 wxGrid *arg1 = (wxGrid *) 0 ;
17784 wxColour *arg2 = 0 ;
17785 void *argp1 = 0 ;
17786 int res1 = 0 ;
17787 wxColour temp2 ;
17788 PyObject * obj0 = 0 ;
17789 PyObject * obj1 = 0 ;
17790 char * kwnames[] = {
17791 (char *) "self",(char *) "c", NULL
17792 };
17793
17794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetSelectionForeground",kwnames,&obj0,&obj1)) SWIG_fail;
17795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17796 if (!SWIG_IsOK(res1)) {
17797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetSelectionForeground" "', expected argument " "1"" of type '" "wxGrid *""'");
17798 }
17799 arg1 = reinterpret_cast< wxGrid * >(argp1);
17800 {
17801 arg2 = &temp2;
17802 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
17803 }
17804 {
17805 PyThreadState* __tstate = wxPyBeginAllowThreads();
17806 (arg1)->SetSelectionForeground((wxColour const &)*arg2);
17807 wxPyEndAllowThreads(__tstate);
17808 if (PyErr_Occurred()) SWIG_fail;
17809 }
17810 resultobj = SWIG_Py_Void();
17811 return resultobj;
17812 fail:
17813 return NULL;
17814 }
17815
17816
17817 SWIGINTERN PyObject *_wrap_Grid_RegisterDataType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17818 PyObject *resultobj = 0;
17819 wxGrid *arg1 = (wxGrid *) 0 ;
17820 wxString *arg2 = 0 ;
17821 wxGridCellRenderer *arg3 = (wxGridCellRenderer *) 0 ;
17822 wxGridCellEditor *arg4 = (wxGridCellEditor *) 0 ;
17823 void *argp1 = 0 ;
17824 int res1 = 0 ;
17825 bool temp2 = false ;
17826 void *argp3 = 0 ;
17827 int res3 = 0 ;
17828 void *argp4 = 0 ;
17829 int res4 = 0 ;
17830 PyObject * obj0 = 0 ;
17831 PyObject * obj1 = 0 ;
17832 PyObject * obj2 = 0 ;
17833 PyObject * obj3 = 0 ;
17834 char * kwnames[] = {
17835 (char *) "self",(char *) "typeName",(char *) "renderer",(char *) "editor", NULL
17836 };
17837
17838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Grid_RegisterDataType",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17840 if (!SWIG_IsOK(res1)) {
17841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_RegisterDataType" "', expected argument " "1"" of type '" "wxGrid *""'");
17842 }
17843 arg1 = reinterpret_cast< wxGrid * >(argp1);
17844 {
17845 arg2 = wxString_in_helper(obj1);
17846 if (arg2 == NULL) SWIG_fail;
17847 temp2 = true;
17848 }
17849 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGridCellRenderer, 0 | 0 );
17850 if (!SWIG_IsOK(res3)) {
17851 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Grid_RegisterDataType" "', expected argument " "3"" of type '" "wxGridCellRenderer *""'");
17852 }
17853 arg3 = reinterpret_cast< wxGridCellRenderer * >(argp3);
17854 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGridCellEditor, 0 | 0 );
17855 if (!SWIG_IsOK(res4)) {
17856 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Grid_RegisterDataType" "', expected argument " "4"" of type '" "wxGridCellEditor *""'");
17857 }
17858 arg4 = reinterpret_cast< wxGridCellEditor * >(argp4);
17859 {
17860 PyThreadState* __tstate = wxPyBeginAllowThreads();
17861 (arg1)->RegisterDataType((wxString const &)*arg2,arg3,arg4);
17862 wxPyEndAllowThreads(__tstate);
17863 if (PyErr_Occurred()) SWIG_fail;
17864 }
17865 resultobj = SWIG_Py_Void();
17866 {
17867 if (temp2)
17868 delete arg2;
17869 }
17870 return resultobj;
17871 fail:
17872 {
17873 if (temp2)
17874 delete arg2;
17875 }
17876 return NULL;
17877 }
17878
17879
17880 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17881 PyObject *resultobj = 0;
17882 wxGrid *arg1 = (wxGrid *) 0 ;
17883 int arg2 ;
17884 int arg3 ;
17885 wxGridCellEditor *result = 0 ;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 int val2 ;
17889 int ecode2 = 0 ;
17890 int val3 ;
17891 int ecode3 = 0 ;
17892 PyObject * obj0 = 0 ;
17893 PyObject * obj1 = 0 ;
17894 PyObject * obj2 = 0 ;
17895 char * kwnames[] = {
17896 (char *) "self",(char *) "row",(char *) "col", NULL
17897 };
17898
17899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultEditorForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17901 if (!SWIG_IsOK(res1)) {
17902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
17903 }
17904 arg1 = reinterpret_cast< wxGrid * >(argp1);
17905 ecode2 = SWIG_AsVal_int(obj1, &val2);
17906 if (!SWIG_IsOK(ecode2)) {
17907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "2"" of type '" "int""'");
17908 }
17909 arg2 = static_cast< int >(val2);
17910 ecode3 = SWIG_AsVal_int(obj2, &val3);
17911 if (!SWIG_IsOK(ecode3)) {
17912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultEditorForCell" "', expected argument " "3"" of type '" "int""'");
17913 }
17914 arg3 = static_cast< int >(val3);
17915 {
17916 PyThreadState* __tstate = wxPyBeginAllowThreads();
17917 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForCell(arg2,arg3);
17918 wxPyEndAllowThreads(__tstate);
17919 if (PyErr_Occurred()) SWIG_fail;
17920 }
17921 {
17922 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
17923 }
17924 return resultobj;
17925 fail:
17926 return NULL;
17927 }
17928
17929
17930 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17931 PyObject *resultobj = 0;
17932 wxGrid *arg1 = (wxGrid *) 0 ;
17933 int arg2 ;
17934 int arg3 ;
17935 wxGridCellRenderer *result = 0 ;
17936 void *argp1 = 0 ;
17937 int res1 = 0 ;
17938 int val2 ;
17939 int ecode2 = 0 ;
17940 int val3 ;
17941 int ecode3 = 0 ;
17942 PyObject * obj0 = 0 ;
17943 PyObject * obj1 = 0 ;
17944 PyObject * obj2 = 0 ;
17945 char * kwnames[] = {
17946 (char *) "self",(char *) "row",(char *) "col", NULL
17947 };
17948
17949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_GetDefaultRendererForCell",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17951 if (!SWIG_IsOK(res1)) {
17952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "1"" of type '" "wxGrid const *""'");
17953 }
17954 arg1 = reinterpret_cast< wxGrid * >(argp1);
17955 ecode2 = SWIG_AsVal_int(obj1, &val2);
17956 if (!SWIG_IsOK(ecode2)) {
17957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "2"" of type '" "int""'");
17958 }
17959 arg2 = static_cast< int >(val2);
17960 ecode3 = SWIG_AsVal_int(obj2, &val3);
17961 if (!SWIG_IsOK(ecode3)) {
17962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_GetDefaultRendererForCell" "', expected argument " "3"" of type '" "int""'");
17963 }
17964 arg3 = static_cast< int >(val3);
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForCell(arg2,arg3);
17968 wxPyEndAllowThreads(__tstate);
17969 if (PyErr_Occurred()) SWIG_fail;
17970 }
17971 {
17972 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
17973 }
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *_wrap_Grid_GetDefaultEditorForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17981 PyObject *resultobj = 0;
17982 wxGrid *arg1 = (wxGrid *) 0 ;
17983 wxString *arg2 = 0 ;
17984 wxGridCellEditor *result = 0 ;
17985 void *argp1 = 0 ;
17986 int res1 = 0 ;
17987 bool temp2 = false ;
17988 PyObject * obj0 = 0 ;
17989 PyObject * obj1 = 0 ;
17990 char * kwnames[] = {
17991 (char *) "self",(char *) "typeName", NULL
17992 };
17993
17994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultEditorForType",kwnames,&obj0,&obj1)) SWIG_fail;
17995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
17996 if (!SWIG_IsOK(res1)) {
17997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultEditorForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
17998 }
17999 arg1 = reinterpret_cast< wxGrid * >(argp1);
18000 {
18001 arg2 = wxString_in_helper(obj1);
18002 if (arg2 == NULL) SWIG_fail;
18003 temp2 = true;
18004 }
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 result = (wxGridCellEditor *)((wxGrid const *)arg1)->GetDefaultEditorForType((wxString const &)*arg2);
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 {
18012 resultobj = wxPyMake_wxGridCellEditor(result, (bool)0);
18013 }
18014 {
18015 if (temp2)
18016 delete arg2;
18017 }
18018 return resultobj;
18019 fail:
18020 {
18021 if (temp2)
18022 delete arg2;
18023 }
18024 return NULL;
18025 }
18026
18027
18028 SWIGINTERN PyObject *_wrap_Grid_GetDefaultRendererForType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18029 PyObject *resultobj = 0;
18030 wxGrid *arg1 = (wxGrid *) 0 ;
18031 wxString *arg2 = 0 ;
18032 wxGridCellRenderer *result = 0 ;
18033 void *argp1 = 0 ;
18034 int res1 = 0 ;
18035 bool temp2 = false ;
18036 PyObject * obj0 = 0 ;
18037 PyObject * obj1 = 0 ;
18038 char * kwnames[] = {
18039 (char *) "self",(char *) "typeName", NULL
18040 };
18041
18042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetDefaultRendererForType",kwnames,&obj0,&obj1)) SWIG_fail;
18043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18044 if (!SWIG_IsOK(res1)) {
18045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetDefaultRendererForType" "', expected argument " "1"" of type '" "wxGrid const *""'");
18046 }
18047 arg1 = reinterpret_cast< wxGrid * >(argp1);
18048 {
18049 arg2 = wxString_in_helper(obj1);
18050 if (arg2 == NULL) SWIG_fail;
18051 temp2 = true;
18052 }
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 result = (wxGridCellRenderer *)((wxGrid const *)arg1)->GetDefaultRendererForType((wxString const &)*arg2);
18056 wxPyEndAllowThreads(__tstate);
18057 if (PyErr_Occurred()) SWIG_fail;
18058 }
18059 {
18060 resultobj = wxPyMake_wxGridCellRenderer(result, (bool)0);
18061 }
18062 {
18063 if (temp2)
18064 delete arg2;
18065 }
18066 return resultobj;
18067 fail:
18068 {
18069 if (temp2)
18070 delete arg2;
18071 }
18072 return NULL;
18073 }
18074
18075
18076 SWIGINTERN PyObject *_wrap_Grid_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18077 PyObject *resultobj = 0;
18078 wxGrid *arg1 = (wxGrid *) 0 ;
18079 int arg2 ;
18080 int arg3 ;
18081 void *argp1 = 0 ;
18082 int res1 = 0 ;
18083 int val2 ;
18084 int ecode2 = 0 ;
18085 int val3 ;
18086 int ecode3 = 0 ;
18087 PyObject * obj0 = 0 ;
18088 PyObject * obj1 = 0 ;
18089 PyObject * obj2 = 0 ;
18090 char * kwnames[] = {
18091 (char *) "self",(char *) "extraWidth",(char *) "extraHeight", NULL
18092 };
18093
18094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Grid_SetMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18096 if (!SWIG_IsOK(res1)) {
18097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetMargins" "', expected argument " "1"" of type '" "wxGrid *""'");
18098 }
18099 arg1 = reinterpret_cast< wxGrid * >(argp1);
18100 ecode2 = SWIG_AsVal_int(obj1, &val2);
18101 if (!SWIG_IsOK(ecode2)) {
18102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetMargins" "', expected argument " "2"" of type '" "int""'");
18103 }
18104 arg2 = static_cast< int >(val2);
18105 ecode3 = SWIG_AsVal_int(obj2, &val3);
18106 if (!SWIG_IsOK(ecode3)) {
18107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Grid_SetMargins" "', expected argument " "3"" of type '" "int""'");
18108 }
18109 arg3 = static_cast< int >(val3);
18110 {
18111 PyThreadState* __tstate = wxPyBeginAllowThreads();
18112 (arg1)->SetMargins(arg2,arg3);
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 resultobj = SWIG_Py_Void();
18117 return resultobj;
18118 fail:
18119 return NULL;
18120 }
18121
18122
18123 SWIGINTERN PyObject *_wrap_Grid_GetGridWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18124 PyObject *resultobj = 0;
18125 wxGrid *arg1 = (wxGrid *) 0 ;
18126 wxWindow *result = 0 ;
18127 void *argp1 = 0 ;
18128 int res1 = 0 ;
18129 PyObject *swig_obj[1] ;
18130
18131 if (!args) SWIG_fail;
18132 swig_obj[0] = args;
18133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18134 if (!SWIG_IsOK(res1)) {
18135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18136 }
18137 arg1 = reinterpret_cast< wxGrid * >(argp1);
18138 {
18139 PyThreadState* __tstate = wxPyBeginAllowThreads();
18140 result = (wxWindow *)(arg1)->GetGridWindow();
18141 wxPyEndAllowThreads(__tstate);
18142 if (PyErr_Occurred()) SWIG_fail;
18143 }
18144 {
18145 resultobj = wxPyMake_wxObject(result, 0);
18146 }
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 SWIGINTERN PyObject *_wrap_Grid_GetGridRowLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18154 PyObject *resultobj = 0;
18155 wxGrid *arg1 = (wxGrid *) 0 ;
18156 wxWindow *result = 0 ;
18157 void *argp1 = 0 ;
18158 int res1 = 0 ;
18159 PyObject *swig_obj[1] ;
18160
18161 if (!args) SWIG_fail;
18162 swig_obj[0] = args;
18163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18164 if (!SWIG_IsOK(res1)) {
18165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridRowLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18166 }
18167 arg1 = reinterpret_cast< wxGrid * >(argp1);
18168 {
18169 PyThreadState* __tstate = wxPyBeginAllowThreads();
18170 result = (wxWindow *)(arg1)->GetGridRowLabelWindow();
18171 wxPyEndAllowThreads(__tstate);
18172 if (PyErr_Occurred()) SWIG_fail;
18173 }
18174 {
18175 resultobj = wxPyMake_wxObject(result, 0);
18176 }
18177 return resultobj;
18178 fail:
18179 return NULL;
18180 }
18181
18182
18183 SWIGINTERN PyObject *_wrap_Grid_GetGridColLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18184 PyObject *resultobj = 0;
18185 wxGrid *arg1 = (wxGrid *) 0 ;
18186 wxWindow *result = 0 ;
18187 void *argp1 = 0 ;
18188 int res1 = 0 ;
18189 PyObject *swig_obj[1] ;
18190
18191 if (!args) SWIG_fail;
18192 swig_obj[0] = args;
18193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18194 if (!SWIG_IsOK(res1)) {
18195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridColLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18196 }
18197 arg1 = reinterpret_cast< wxGrid * >(argp1);
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = (wxWindow *)(arg1)->GetGridColLabelWindow();
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 {
18205 resultobj = wxPyMake_wxObject(result, 0);
18206 }
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 SWIGINTERN PyObject *_wrap_Grid_GetGridCornerLabelWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18214 PyObject *resultobj = 0;
18215 wxGrid *arg1 = (wxGrid *) 0 ;
18216 wxWindow *result = 0 ;
18217 void *argp1 = 0 ;
18218 int res1 = 0 ;
18219 PyObject *swig_obj[1] ;
18220
18221 if (!args) SWIG_fail;
18222 swig_obj[0] = args;
18223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18224 if (!SWIG_IsOK(res1)) {
18225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetGridCornerLabelWindow" "', expected argument " "1"" of type '" "wxGrid *""'");
18226 }
18227 arg1 = reinterpret_cast< wxGrid * >(argp1);
18228 {
18229 PyThreadState* __tstate = wxPyBeginAllowThreads();
18230 result = (wxWindow *)(arg1)->GetGridCornerLabelWindow();
18231 wxPyEndAllowThreads(__tstate);
18232 if (PyErr_Occurred()) SWIG_fail;
18233 }
18234 {
18235 resultobj = wxPyMake_wxObject(result, 0);
18236 }
18237 return resultobj;
18238 fail:
18239 return NULL;
18240 }
18241
18242
18243 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18244 PyObject *resultobj = 0;
18245 wxGrid *arg1 = (wxGrid *) 0 ;
18246 int arg2 ;
18247 void *argp1 = 0 ;
18248 int res1 = 0 ;
18249 int val2 ;
18250 int ecode2 = 0 ;
18251 PyObject * obj0 = 0 ;
18252 PyObject * obj1 = 0 ;
18253 char * kwnames[] = {
18254 (char *) "self",(char *) "x", NULL
18255 };
18256
18257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineX",kwnames,&obj0,&obj1)) SWIG_fail;
18258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18259 if (!SWIG_IsOK(res1)) {
18260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineX" "', expected argument " "1"" of type '" "wxGrid *""'");
18261 }
18262 arg1 = reinterpret_cast< wxGrid * >(argp1);
18263 ecode2 = SWIG_AsVal_int(obj1, &val2);
18264 if (!SWIG_IsOK(ecode2)) {
18265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineX" "', expected argument " "2"" of type '" "int""'");
18266 }
18267 arg2 = static_cast< int >(val2);
18268 {
18269 PyThreadState* __tstate = wxPyBeginAllowThreads();
18270 (arg1)->SetScrollLineX(arg2);
18271 wxPyEndAllowThreads(__tstate);
18272 if (PyErr_Occurred()) SWIG_fail;
18273 }
18274 resultobj = SWIG_Py_Void();
18275 return resultobj;
18276 fail:
18277 return NULL;
18278 }
18279
18280
18281 SWIGINTERN PyObject *_wrap_Grid_SetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18282 PyObject *resultobj = 0;
18283 wxGrid *arg1 = (wxGrid *) 0 ;
18284 int arg2 ;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 int val2 ;
18288 int ecode2 = 0 ;
18289 PyObject * obj0 = 0 ;
18290 PyObject * obj1 = 0 ;
18291 char * kwnames[] = {
18292 (char *) "self",(char *) "y", NULL
18293 };
18294
18295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_SetScrollLineY",kwnames,&obj0,&obj1)) SWIG_fail;
18296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18297 if (!SWIG_IsOK(res1)) {
18298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_SetScrollLineY" "', expected argument " "1"" of type '" "wxGrid *""'");
18299 }
18300 arg1 = reinterpret_cast< wxGrid * >(argp1);
18301 ecode2 = SWIG_AsVal_int(obj1, &val2);
18302 if (!SWIG_IsOK(ecode2)) {
18303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_SetScrollLineY" "', expected argument " "2"" of type '" "int""'");
18304 }
18305 arg2 = static_cast< int >(val2);
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 (arg1)->SetScrollLineY(arg2);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = SWIG_Py_Void();
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18320 PyObject *resultobj = 0;
18321 wxGrid *arg1 = (wxGrid *) 0 ;
18322 int result;
18323 void *argp1 = 0 ;
18324 int res1 = 0 ;
18325 PyObject *swig_obj[1] ;
18326
18327 if (!args) SWIG_fail;
18328 swig_obj[0] = args;
18329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18330 if (!SWIG_IsOK(res1)) {
18331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18332 }
18333 arg1 = reinterpret_cast< wxGrid * >(argp1);
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 result = (int)((wxGrid const *)arg1)->GetScrollLineX();
18337 wxPyEndAllowThreads(__tstate);
18338 if (PyErr_Occurred()) SWIG_fail;
18339 }
18340 resultobj = SWIG_From_int(static_cast< int >(result));
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 SWIGINTERN PyObject *_wrap_Grid_GetScrollLineY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18348 PyObject *resultobj = 0;
18349 wxGrid *arg1 = (wxGrid *) 0 ;
18350 int result;
18351 void *argp1 = 0 ;
18352 int res1 = 0 ;
18353 PyObject *swig_obj[1] ;
18354
18355 if (!args) SWIG_fail;
18356 swig_obj[0] = args;
18357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18358 if (!SWIG_IsOK(res1)) {
18359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollLineY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18360 }
18361 arg1 = reinterpret_cast< wxGrid * >(argp1);
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 result = (int)((wxGrid const *)arg1)->GetScrollLineY();
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 resultobj = SWIG_From_int(static_cast< int >(result));
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 SWIGINTERN PyObject *_wrap_Grid_GetScrollX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj = 0;
18377 wxGrid *arg1 = (wxGrid *) 0 ;
18378 int arg2 ;
18379 int result;
18380 void *argp1 = 0 ;
18381 int res1 = 0 ;
18382 int val2 ;
18383 int ecode2 = 0 ;
18384 PyObject * obj0 = 0 ;
18385 PyObject * obj1 = 0 ;
18386 char * kwnames[] = {
18387 (char *) "self",(char *) "x", NULL
18388 };
18389
18390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollX",kwnames,&obj0,&obj1)) SWIG_fail;
18391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18392 if (!SWIG_IsOK(res1)) {
18393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollX" "', expected argument " "1"" of type '" "wxGrid const *""'");
18394 }
18395 arg1 = reinterpret_cast< wxGrid * >(argp1);
18396 ecode2 = SWIG_AsVal_int(obj1, &val2);
18397 if (!SWIG_IsOK(ecode2)) {
18398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollX" "', expected argument " "2"" of type '" "int""'");
18399 }
18400 arg2 = static_cast< int >(val2);
18401 {
18402 PyThreadState* __tstate = wxPyBeginAllowThreads();
18403 result = (int)((wxGrid const *)arg1)->GetScrollX(arg2);
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 resultobj = SWIG_From_int(static_cast< int >(result));
18408 return resultobj;
18409 fail:
18410 return NULL;
18411 }
18412
18413
18414 SWIGINTERN PyObject *_wrap_Grid_GetScrollY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18415 PyObject *resultobj = 0;
18416 wxGrid *arg1 = (wxGrid *) 0 ;
18417 int arg2 ;
18418 int result;
18419 void *argp1 = 0 ;
18420 int res1 = 0 ;
18421 int val2 ;
18422 int ecode2 = 0 ;
18423 PyObject * obj0 = 0 ;
18424 PyObject * obj1 = 0 ;
18425 char * kwnames[] = {
18426 (char *) "self",(char *) "y", NULL
18427 };
18428
18429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Grid_GetScrollY",kwnames,&obj0,&obj1)) SWIG_fail;
18430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGrid, 0 | 0 );
18431 if (!SWIG_IsOK(res1)) {
18432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid_GetScrollY" "', expected argument " "1"" of type '" "wxGrid const *""'");
18433 }
18434 arg1 = reinterpret_cast< wxGrid * >(argp1);
18435 ecode2 = SWIG_AsVal_int(obj1, &val2);
18436 if (!SWIG_IsOK(ecode2)) {
18437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Grid_GetScrollY" "', expected argument " "2"" of type '" "int""'");
18438 }
18439 arg2 = static_cast< int >(val2);
18440 {
18441 PyThreadState* __tstate = wxPyBeginAllowThreads();
18442 result = (int)((wxGrid const *)arg1)->GetScrollY(arg2);
18443 wxPyEndAllowThreads(__tstate);
18444 if (PyErr_Occurred()) SWIG_fail;
18445 }
18446 resultobj = SWIG_From_int(static_cast< int >(result));
18447 return resultobj;
18448 fail:
18449 return NULL;
18450 }
18451
18452
18453 SWIGINTERN PyObject *_wrap_Grid_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18454 PyObject *resultobj = 0;
18455 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
18456 SwigValueWrapper<wxVisualAttributes > result;
18457 int val1 ;
18458 int ecode1 = 0 ;
18459 PyObject * obj0 = 0 ;
18460 char * kwnames[] = {
18461 (char *) "variant", NULL
18462 };
18463
18464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Grid_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
18465 if (obj0) {
18466 ecode1 = SWIG_AsVal_int(obj0, &val1);
18467 if (!SWIG_IsOK(ecode1)) {
18468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Grid_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
18469 }
18470 arg1 = static_cast< wxWindowVariant >(val1);
18471 }
18472 {
18473 if (!wxPyCheckForApp()) SWIG_fail;
18474 PyThreadState* __tstate = wxPyBeginAllowThreads();
18475 result = wxGrid::GetClassDefaultAttributes(arg1);
18476 wxPyEndAllowThreads(__tstate);
18477 if (PyErr_Occurred()) SWIG_fail;
18478 }
18479 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
18480 return resultobj;
18481 fail:
18482 return NULL;
18483 }
18484
18485
18486 SWIGINTERN PyObject *Grid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18487 PyObject *obj;
18488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18489 SWIG_TypeNewClientData(SWIGTYPE_p_wxGrid, SWIG_NewClientData(obj));
18490 return SWIG_Py_Void();
18491 }
18492
18493 SWIGINTERN PyObject *Grid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18494 return SWIG_Python_InitShadowInstance(args);
18495 }
18496
18497 SWIGINTERN PyObject *_wrap_new_GridEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18498 PyObject *resultobj = 0;
18499 int arg1 ;
18500 wxEventType arg2 ;
18501 wxGrid *arg3 = (wxGrid *) 0 ;
18502 int arg4 = (int) -1 ;
18503 int arg5 = (int) -1 ;
18504 int arg6 = (int) -1 ;
18505 int arg7 = (int) -1 ;
18506 bool arg8 = (bool) true ;
18507 bool arg9 = (bool) false ;
18508 bool arg10 = (bool) false ;
18509 bool arg11 = (bool) false ;
18510 bool arg12 = (bool) false ;
18511 wxGridEvent *result = 0 ;
18512 int val1 ;
18513 int ecode1 = 0 ;
18514 int val2 ;
18515 int ecode2 = 0 ;
18516 void *argp3 = 0 ;
18517 int res3 = 0 ;
18518 int val4 ;
18519 int ecode4 = 0 ;
18520 int val5 ;
18521 int ecode5 = 0 ;
18522 int val6 ;
18523 int ecode6 = 0 ;
18524 int val7 ;
18525 int ecode7 = 0 ;
18526 bool val8 ;
18527 int ecode8 = 0 ;
18528 bool val9 ;
18529 int ecode9 = 0 ;
18530 bool val10 ;
18531 int ecode10 = 0 ;
18532 bool val11 ;
18533 int ecode11 = 0 ;
18534 bool val12 ;
18535 int ecode12 = 0 ;
18536 PyObject * obj0 = 0 ;
18537 PyObject * obj1 = 0 ;
18538 PyObject * obj2 = 0 ;
18539 PyObject * obj3 = 0 ;
18540 PyObject * obj4 = 0 ;
18541 PyObject * obj5 = 0 ;
18542 PyObject * obj6 = 0 ;
18543 PyObject * obj7 = 0 ;
18544 PyObject * obj8 = 0 ;
18545 PyObject * obj9 = 0 ;
18546 PyObject * obj10 = 0 ;
18547 PyObject * obj11 = 0 ;
18548 char * kwnames[] = {
18549 (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
18550 };
18551
18552 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;
18553 ecode1 = SWIG_AsVal_int(obj0, &val1);
18554 if (!SWIG_IsOK(ecode1)) {
18555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEvent" "', expected argument " "1"" of type '" "int""'");
18556 }
18557 arg1 = static_cast< int >(val1);
18558 ecode2 = SWIG_AsVal_int(obj1, &val2);
18559 if (!SWIG_IsOK(ecode2)) {
18560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18561 }
18562 arg2 = static_cast< wxEventType >(val2);
18563 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18564 if (!SWIG_IsOK(res3)) {
18565 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18566 }
18567 arg3 = reinterpret_cast< wxGrid * >(argp3);
18568 if (obj3) {
18569 ecode4 = SWIG_AsVal_int(obj3, &val4);
18570 if (!SWIG_IsOK(ecode4)) {
18571 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEvent" "', expected argument " "4"" of type '" "int""'");
18572 }
18573 arg4 = static_cast< int >(val4);
18574 }
18575 if (obj4) {
18576 ecode5 = SWIG_AsVal_int(obj4, &val5);
18577 if (!SWIG_IsOK(ecode5)) {
18578 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEvent" "', expected argument " "5"" of type '" "int""'");
18579 }
18580 arg5 = static_cast< int >(val5);
18581 }
18582 if (obj5) {
18583 ecode6 = SWIG_AsVal_int(obj5, &val6);
18584 if (!SWIG_IsOK(ecode6)) {
18585 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridEvent" "', expected argument " "6"" of type '" "int""'");
18586 }
18587 arg6 = static_cast< int >(val6);
18588 }
18589 if (obj6) {
18590 ecode7 = SWIG_AsVal_int(obj6, &val7);
18591 if (!SWIG_IsOK(ecode7)) {
18592 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridEvent" "', expected argument " "7"" of type '" "int""'");
18593 }
18594 arg7 = static_cast< int >(val7);
18595 }
18596 if (obj7) {
18597 ecode8 = SWIG_AsVal_bool(obj7, &val8);
18598 if (!SWIG_IsOK(ecode8)) {
18599 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridEvent" "', expected argument " "8"" of type '" "bool""'");
18600 }
18601 arg8 = static_cast< bool >(val8);
18602 }
18603 if (obj8) {
18604 ecode9 = SWIG_AsVal_bool(obj8, &val9);
18605 if (!SWIG_IsOK(ecode9)) {
18606 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridEvent" "', expected argument " "9"" of type '" "bool""'");
18607 }
18608 arg9 = static_cast< bool >(val9);
18609 }
18610 if (obj9) {
18611 ecode10 = SWIG_AsVal_bool(obj9, &val10);
18612 if (!SWIG_IsOK(ecode10)) {
18613 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridEvent" "', expected argument " "10"" of type '" "bool""'");
18614 }
18615 arg10 = static_cast< bool >(val10);
18616 }
18617 if (obj10) {
18618 ecode11 = SWIG_AsVal_bool(obj10, &val11);
18619 if (!SWIG_IsOK(ecode11)) {
18620 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GridEvent" "', expected argument " "11"" of type '" "bool""'");
18621 }
18622 arg11 = static_cast< bool >(val11);
18623 }
18624 if (obj11) {
18625 ecode12 = SWIG_AsVal_bool(obj11, &val12);
18626 if (!SWIG_IsOK(ecode12)) {
18627 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_GridEvent" "', expected argument " "12"" of type '" "bool""'");
18628 }
18629 arg12 = static_cast< bool >(val12);
18630 }
18631 {
18632 PyThreadState* __tstate = wxPyBeginAllowThreads();
18633 result = (wxGridEvent *)new wxGridEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
18634 wxPyEndAllowThreads(__tstate);
18635 if (PyErr_Occurred()) SWIG_fail;
18636 }
18637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEvent, SWIG_POINTER_NEW | 0 );
18638 return resultobj;
18639 fail:
18640 return NULL;
18641 }
18642
18643
18644 SWIGINTERN PyObject *_wrap_GridEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18645 PyObject *resultobj = 0;
18646 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18647 int result;
18648 void *argp1 = 0 ;
18649 int res1 = 0 ;
18650 PyObject *swig_obj[1] ;
18651
18652 if (!args) SWIG_fail;
18653 swig_obj[0] = args;
18654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18655 if (!SWIG_IsOK(res1)) {
18656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18657 }
18658 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18659 {
18660 PyThreadState* __tstate = wxPyBeginAllowThreads();
18661 result = (int)(arg1)->GetRow();
18662 wxPyEndAllowThreads(__tstate);
18663 if (PyErr_Occurred()) SWIG_fail;
18664 }
18665 resultobj = SWIG_From_int(static_cast< int >(result));
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 SWIGINTERN PyObject *_wrap_GridEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18673 PyObject *resultobj = 0;
18674 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18675 int result;
18676 void *argp1 = 0 ;
18677 int res1 = 0 ;
18678 PyObject *swig_obj[1] ;
18679
18680 if (!args) SWIG_fail;
18681 swig_obj[0] = args;
18682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18683 if (!SWIG_IsOK(res1)) {
18684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18685 }
18686 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18687 {
18688 PyThreadState* __tstate = wxPyBeginAllowThreads();
18689 result = (int)(arg1)->GetCol();
18690 wxPyEndAllowThreads(__tstate);
18691 if (PyErr_Occurred()) SWIG_fail;
18692 }
18693 resultobj = SWIG_From_int(static_cast< int >(result));
18694 return resultobj;
18695 fail:
18696 return NULL;
18697 }
18698
18699
18700 SWIGINTERN PyObject *_wrap_GridEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18701 PyObject *resultobj = 0;
18702 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18703 wxPoint result;
18704 void *argp1 = 0 ;
18705 int res1 = 0 ;
18706 PyObject *swig_obj[1] ;
18707
18708 if (!args) SWIG_fail;
18709 swig_obj[0] = args;
18710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18711 if (!SWIG_IsOK(res1)) {
18712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18713 }
18714 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 result = (arg1)->GetPosition();
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 SWIGINTERN PyObject *_wrap_GridEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18729 PyObject *resultobj = 0;
18730 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18731 bool result;
18732 void *argp1 = 0 ;
18733 int res1 = 0 ;
18734 PyObject *swig_obj[1] ;
18735
18736 if (!args) SWIG_fail;
18737 swig_obj[0] = args;
18738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18739 if (!SWIG_IsOK(res1)) {
18740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_Selecting" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18741 }
18742 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18743 {
18744 PyThreadState* __tstate = wxPyBeginAllowThreads();
18745 result = (bool)(arg1)->Selecting();
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 {
18750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18751 }
18752 return resultobj;
18753 fail:
18754 return NULL;
18755 }
18756
18757
18758 SWIGINTERN PyObject *_wrap_GridEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18759 PyObject *resultobj = 0;
18760 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18761 bool result;
18762 void *argp1 = 0 ;
18763 int res1 = 0 ;
18764 PyObject *swig_obj[1] ;
18765
18766 if (!args) SWIG_fail;
18767 swig_obj[0] = args;
18768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18769 if (!SWIG_IsOK(res1)) {
18770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18771 }
18772 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (bool)(arg1)->ControlDown();
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 {
18780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18781 }
18782 return resultobj;
18783 fail:
18784 return NULL;
18785 }
18786
18787
18788 SWIGINTERN PyObject *_wrap_GridEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18789 PyObject *resultobj = 0;
18790 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18791 bool result;
18792 void *argp1 = 0 ;
18793 int res1 = 0 ;
18794 PyObject *swig_obj[1] ;
18795
18796 if (!args) SWIG_fail;
18797 swig_obj[0] = args;
18798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18799 if (!SWIG_IsOK(res1)) {
18800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18801 }
18802 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18803 {
18804 PyThreadState* __tstate = wxPyBeginAllowThreads();
18805 result = (bool)(arg1)->MetaDown();
18806 wxPyEndAllowThreads(__tstate);
18807 if (PyErr_Occurred()) SWIG_fail;
18808 }
18809 {
18810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18811 }
18812 return resultobj;
18813 fail:
18814 return NULL;
18815 }
18816
18817
18818 SWIGINTERN PyObject *_wrap_GridEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18819 PyObject *resultobj = 0;
18820 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18821 bool result;
18822 void *argp1 = 0 ;
18823 int res1 = 0 ;
18824 PyObject *swig_obj[1] ;
18825
18826 if (!args) SWIG_fail;
18827 swig_obj[0] = args;
18828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18829 if (!SWIG_IsOK(res1)) {
18830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18831 }
18832 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18833 {
18834 PyThreadState* __tstate = wxPyBeginAllowThreads();
18835 result = (bool)(arg1)->ShiftDown();
18836 wxPyEndAllowThreads(__tstate);
18837 if (PyErr_Occurred()) SWIG_fail;
18838 }
18839 {
18840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18841 }
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 SWIGINTERN PyObject *_wrap_GridEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18849 PyObject *resultobj = 0;
18850 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18851 bool result;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 PyObject *swig_obj[1] ;
18855
18856 if (!args) SWIG_fail;
18857 swig_obj[0] = args;
18858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18859 if (!SWIG_IsOK(res1)) {
18860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_AltDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18861 }
18862 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18863 {
18864 PyThreadState* __tstate = wxPyBeginAllowThreads();
18865 result = (bool)(arg1)->AltDown();
18866 wxPyEndAllowThreads(__tstate);
18867 if (PyErr_Occurred()) SWIG_fail;
18868 }
18869 {
18870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18871 }
18872 return resultobj;
18873 fail:
18874 return NULL;
18875 }
18876
18877
18878 SWIGINTERN PyObject *_wrap_GridEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18879 PyObject *resultobj = 0;
18880 wxGridEvent *arg1 = (wxGridEvent *) 0 ;
18881 bool result;
18882 void *argp1 = 0 ;
18883 int res1 = 0 ;
18884 PyObject *swig_obj[1] ;
18885
18886 if (!args) SWIG_fail;
18887 swig_obj[0] = args;
18888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEvent, 0 | 0 );
18889 if (!SWIG_IsOK(res1)) {
18890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridEvent *""'");
18891 }
18892 arg1 = reinterpret_cast< wxGridEvent * >(argp1);
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 result = (bool)(arg1)->CmdDown();
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 {
18900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18901 }
18902 return resultobj;
18903 fail:
18904 return NULL;
18905 }
18906
18907
18908 SWIGINTERN PyObject *GridEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18909 PyObject *obj;
18910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18911 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEvent, SWIG_NewClientData(obj));
18912 return SWIG_Py_Void();
18913 }
18914
18915 SWIGINTERN PyObject *GridEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18916 return SWIG_Python_InitShadowInstance(args);
18917 }
18918
18919 SWIGINTERN PyObject *_wrap_new_GridSizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18920 PyObject *resultobj = 0;
18921 int arg1 ;
18922 wxEventType arg2 ;
18923 wxGrid *arg3 = (wxGrid *) 0 ;
18924 int arg4 = (int) -1 ;
18925 int arg5 = (int) -1 ;
18926 int arg6 = (int) -1 ;
18927 bool arg7 = (bool) false ;
18928 bool arg8 = (bool) false ;
18929 bool arg9 = (bool) false ;
18930 bool arg10 = (bool) false ;
18931 wxGridSizeEvent *result = 0 ;
18932 int val1 ;
18933 int ecode1 = 0 ;
18934 int val2 ;
18935 int ecode2 = 0 ;
18936 void *argp3 = 0 ;
18937 int res3 = 0 ;
18938 int val4 ;
18939 int ecode4 = 0 ;
18940 int val5 ;
18941 int ecode5 = 0 ;
18942 int val6 ;
18943 int ecode6 = 0 ;
18944 bool val7 ;
18945 int ecode7 = 0 ;
18946 bool val8 ;
18947 int ecode8 = 0 ;
18948 bool val9 ;
18949 int ecode9 = 0 ;
18950 bool val10 ;
18951 int ecode10 = 0 ;
18952 PyObject * obj0 = 0 ;
18953 PyObject * obj1 = 0 ;
18954 PyObject * obj2 = 0 ;
18955 PyObject * obj3 = 0 ;
18956 PyObject * obj4 = 0 ;
18957 PyObject * obj5 = 0 ;
18958 PyObject * obj6 = 0 ;
18959 PyObject * obj7 = 0 ;
18960 PyObject * obj8 = 0 ;
18961 PyObject * obj9 = 0 ;
18962 char * kwnames[] = {
18963 (char *) "id",(char *) "type",(char *) "obj",(char *) "rowOrCol",(char *) "x",(char *) "y",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
18964 };
18965
18966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOOO:new_GridSizeEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
18967 ecode1 = SWIG_AsVal_int(obj0, &val1);
18968 if (!SWIG_IsOK(ecode1)) {
18969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizeEvent" "', expected argument " "1"" of type '" "int""'");
18970 }
18971 arg1 = static_cast< int >(val1);
18972 ecode2 = SWIG_AsVal_int(obj1, &val2);
18973 if (!SWIG_IsOK(ecode2)) {
18974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizeEvent" "', expected argument " "2"" of type '" "wxEventType""'");
18975 }
18976 arg2 = static_cast< wxEventType >(val2);
18977 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
18978 if (!SWIG_IsOK(res3)) {
18979 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridSizeEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
18980 }
18981 arg3 = reinterpret_cast< wxGrid * >(argp3);
18982 if (obj3) {
18983 ecode4 = SWIG_AsVal_int(obj3, &val4);
18984 if (!SWIG_IsOK(ecode4)) {
18985 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizeEvent" "', expected argument " "4"" of type '" "int""'");
18986 }
18987 arg4 = static_cast< int >(val4);
18988 }
18989 if (obj4) {
18990 ecode5 = SWIG_AsVal_int(obj4, &val5);
18991 if (!SWIG_IsOK(ecode5)) {
18992 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridSizeEvent" "', expected argument " "5"" of type '" "int""'");
18993 }
18994 arg5 = static_cast< int >(val5);
18995 }
18996 if (obj5) {
18997 ecode6 = SWIG_AsVal_int(obj5, &val6);
18998 if (!SWIG_IsOK(ecode6)) {
18999 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridSizeEvent" "', expected argument " "6"" of type '" "int""'");
19000 }
19001 arg6 = static_cast< int >(val6);
19002 }
19003 if (obj6) {
19004 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19005 if (!SWIG_IsOK(ecode7)) {
19006 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridSizeEvent" "', expected argument " "7"" of type '" "bool""'");
19007 }
19008 arg7 = static_cast< bool >(val7);
19009 }
19010 if (obj7) {
19011 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19012 if (!SWIG_IsOK(ecode8)) {
19013 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridSizeEvent" "', expected argument " "8"" of type '" "bool""'");
19014 }
19015 arg8 = static_cast< bool >(val8);
19016 }
19017 if (obj8) {
19018 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19019 if (!SWIG_IsOK(ecode9)) {
19020 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridSizeEvent" "', expected argument " "9"" of type '" "bool""'");
19021 }
19022 arg9 = static_cast< bool >(val9);
19023 }
19024 if (obj9) {
19025 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19026 if (!SWIG_IsOK(ecode10)) {
19027 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridSizeEvent" "', expected argument " "10"" of type '" "bool""'");
19028 }
19029 arg10 = static_cast< bool >(val10);
19030 }
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = (wxGridSizeEvent *)new wxGridSizeEvent(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
19034 wxPyEndAllowThreads(__tstate);
19035 if (PyErr_Occurred()) SWIG_fail;
19036 }
19037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizeEvent, SWIG_POINTER_NEW | 0 );
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetRowOrCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19045 PyObject *resultobj = 0;
19046 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19047 int result;
19048 void *argp1 = 0 ;
19049 int res1 = 0 ;
19050 PyObject *swig_obj[1] ;
19051
19052 if (!args) SWIG_fail;
19053 swig_obj[0] = args;
19054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19055 if (!SWIG_IsOK(res1)) {
19056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetRowOrCol" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19057 }
19058 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 result = (int)(arg1)->GetRowOrCol();
19062 wxPyEndAllowThreads(__tstate);
19063 if (PyErr_Occurred()) SWIG_fail;
19064 }
19065 resultobj = SWIG_From_int(static_cast< int >(result));
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 SWIGINTERN PyObject *_wrap_GridSizeEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19073 PyObject *resultobj = 0;
19074 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19075 wxPoint result;
19076 void *argp1 = 0 ;
19077 int res1 = 0 ;
19078 PyObject *swig_obj[1] ;
19079
19080 if (!args) SWIG_fail;
19081 swig_obj[0] = args;
19082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19083 if (!SWIG_IsOK(res1)) {
19084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_GetPosition" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19085 }
19086 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19087 {
19088 PyThreadState* __tstate = wxPyBeginAllowThreads();
19089 result = (arg1)->GetPosition();
19090 wxPyEndAllowThreads(__tstate);
19091 if (PyErr_Occurred()) SWIG_fail;
19092 }
19093 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 SWIGINTERN PyObject *_wrap_GridSizeEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19101 PyObject *resultobj = 0;
19102 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19103 bool result;
19104 void *argp1 = 0 ;
19105 int res1 = 0 ;
19106 PyObject *swig_obj[1] ;
19107
19108 if (!args) SWIG_fail;
19109 swig_obj[0] = args;
19110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19111 if (!SWIG_IsOK(res1)) {
19112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19113 }
19114 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 result = (bool)(arg1)->ControlDown();
19118 wxPyEndAllowThreads(__tstate);
19119 if (PyErr_Occurred()) SWIG_fail;
19120 }
19121 {
19122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19123 }
19124 return resultobj;
19125 fail:
19126 return NULL;
19127 }
19128
19129
19130 SWIGINTERN PyObject *_wrap_GridSizeEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19131 PyObject *resultobj = 0;
19132 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19133 bool result;
19134 void *argp1 = 0 ;
19135 int res1 = 0 ;
19136 PyObject *swig_obj[1] ;
19137
19138 if (!args) SWIG_fail;
19139 swig_obj[0] = args;
19140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19141 if (!SWIG_IsOK(res1)) {
19142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19143 }
19144 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19145 {
19146 PyThreadState* __tstate = wxPyBeginAllowThreads();
19147 result = (bool)(arg1)->MetaDown();
19148 wxPyEndAllowThreads(__tstate);
19149 if (PyErr_Occurred()) SWIG_fail;
19150 }
19151 {
19152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19153 }
19154 return resultobj;
19155 fail:
19156 return NULL;
19157 }
19158
19159
19160 SWIGINTERN PyObject *_wrap_GridSizeEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19161 PyObject *resultobj = 0;
19162 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19163 bool result;
19164 void *argp1 = 0 ;
19165 int res1 = 0 ;
19166 PyObject *swig_obj[1] ;
19167
19168 if (!args) SWIG_fail;
19169 swig_obj[0] = args;
19170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19171 if (!SWIG_IsOK(res1)) {
19172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19173 }
19174 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19175 {
19176 PyThreadState* __tstate = wxPyBeginAllowThreads();
19177 result = (bool)(arg1)->ShiftDown();
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 {
19182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19183 }
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 SWIGINTERN PyObject *_wrap_GridSizeEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19191 PyObject *resultobj = 0;
19192 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19193 bool result;
19194 void *argp1 = 0 ;
19195 int res1 = 0 ;
19196 PyObject *swig_obj[1] ;
19197
19198 if (!args) SWIG_fail;
19199 swig_obj[0] = args;
19200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19201 if (!SWIG_IsOK(res1)) {
19202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_AltDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19203 }
19204 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19205 {
19206 PyThreadState* __tstate = wxPyBeginAllowThreads();
19207 result = (bool)(arg1)->AltDown();
19208 wxPyEndAllowThreads(__tstate);
19209 if (PyErr_Occurred()) SWIG_fail;
19210 }
19211 {
19212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19213 }
19214 return resultobj;
19215 fail:
19216 return NULL;
19217 }
19218
19219
19220 SWIGINTERN PyObject *_wrap_GridSizeEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19221 PyObject *resultobj = 0;
19222 wxGridSizeEvent *arg1 = (wxGridSizeEvent *) 0 ;
19223 bool result;
19224 void *argp1 = 0 ;
19225 int res1 = 0 ;
19226 PyObject *swig_obj[1] ;
19227
19228 if (!args) SWIG_fail;
19229 swig_obj[0] = args;
19230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizeEvent, 0 | 0 );
19231 if (!SWIG_IsOK(res1)) {
19232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizeEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridSizeEvent *""'");
19233 }
19234 arg1 = reinterpret_cast< wxGridSizeEvent * >(argp1);
19235 {
19236 PyThreadState* __tstate = wxPyBeginAllowThreads();
19237 result = (bool)(arg1)->CmdDown();
19238 wxPyEndAllowThreads(__tstate);
19239 if (PyErr_Occurred()) SWIG_fail;
19240 }
19241 {
19242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19243 }
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 SWIGINTERN PyObject *GridSizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19251 PyObject *obj;
19252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19253 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizeEvent, SWIG_NewClientData(obj));
19254 return SWIG_Py_Void();
19255 }
19256
19257 SWIGINTERN PyObject *GridSizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19258 return SWIG_Python_InitShadowInstance(args);
19259 }
19260
19261 SWIGINTERN PyObject *_wrap_new_GridRangeSelectEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19262 PyObject *resultobj = 0;
19263 int arg1 ;
19264 wxEventType arg2 ;
19265 wxGrid *arg3 = (wxGrid *) 0 ;
19266 wxGridCellCoords *arg4 = 0 ;
19267 wxGridCellCoords *arg5 = 0 ;
19268 bool arg6 = (bool) true ;
19269 bool arg7 = (bool) false ;
19270 bool arg8 = (bool) false ;
19271 bool arg9 = (bool) false ;
19272 bool arg10 = (bool) false ;
19273 wxGridRangeSelectEvent *result = 0 ;
19274 int val1 ;
19275 int ecode1 = 0 ;
19276 int val2 ;
19277 int ecode2 = 0 ;
19278 void *argp3 = 0 ;
19279 int res3 = 0 ;
19280 wxGridCellCoords temp4 ;
19281 wxGridCellCoords temp5 ;
19282 bool val6 ;
19283 int ecode6 = 0 ;
19284 bool val7 ;
19285 int ecode7 = 0 ;
19286 bool val8 ;
19287 int ecode8 = 0 ;
19288 bool val9 ;
19289 int ecode9 = 0 ;
19290 bool val10 ;
19291 int ecode10 = 0 ;
19292 PyObject * obj0 = 0 ;
19293 PyObject * obj1 = 0 ;
19294 PyObject * obj2 = 0 ;
19295 PyObject * obj3 = 0 ;
19296 PyObject * obj4 = 0 ;
19297 PyObject * obj5 = 0 ;
19298 PyObject * obj6 = 0 ;
19299 PyObject * obj7 = 0 ;
19300 PyObject * obj8 = 0 ;
19301 PyObject * obj9 = 0 ;
19302 char * kwnames[] = {
19303 (char *) "id",(char *) "type",(char *) "obj",(char *) "topLeft",(char *) "bottomRight",(char *) "sel",(char *) "control",(char *) "shift",(char *) "alt",(char *) "meta", NULL
19304 };
19305
19306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOOOO:new_GridRangeSelectEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
19307 ecode1 = SWIG_AsVal_int(obj0, &val1);
19308 if (!SWIG_IsOK(ecode1)) {
19309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridRangeSelectEvent" "', expected argument " "1"" of type '" "int""'");
19310 }
19311 arg1 = static_cast< int >(val1);
19312 ecode2 = SWIG_AsVal_int(obj1, &val2);
19313 if (!SWIG_IsOK(ecode2)) {
19314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridRangeSelectEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19315 }
19316 arg2 = static_cast< wxEventType >(val2);
19317 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGrid, 0 | 0 );
19318 if (!SWIG_IsOK(res3)) {
19319 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridRangeSelectEvent" "', expected argument " "3"" of type '" "wxGrid *""'");
19320 }
19321 arg3 = reinterpret_cast< wxGrid * >(argp3);
19322 {
19323 arg4 = &temp4;
19324 if (! wxGridCellCoords_helper(obj3, &arg4)) SWIG_fail;
19325 }
19326 {
19327 arg5 = &temp5;
19328 if (! wxGridCellCoords_helper(obj4, &arg5)) SWIG_fail;
19329 }
19330 if (obj5) {
19331 ecode6 = SWIG_AsVal_bool(obj5, &val6);
19332 if (!SWIG_IsOK(ecode6)) {
19333 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridRangeSelectEvent" "', expected argument " "6"" of type '" "bool""'");
19334 }
19335 arg6 = static_cast< bool >(val6);
19336 }
19337 if (obj6) {
19338 ecode7 = SWIG_AsVal_bool(obj6, &val7);
19339 if (!SWIG_IsOK(ecode7)) {
19340 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GridRangeSelectEvent" "', expected argument " "7"" of type '" "bool""'");
19341 }
19342 arg7 = static_cast< bool >(val7);
19343 }
19344 if (obj7) {
19345 ecode8 = SWIG_AsVal_bool(obj7, &val8);
19346 if (!SWIG_IsOK(ecode8)) {
19347 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GridRangeSelectEvent" "', expected argument " "8"" of type '" "bool""'");
19348 }
19349 arg8 = static_cast< bool >(val8);
19350 }
19351 if (obj8) {
19352 ecode9 = SWIG_AsVal_bool(obj8, &val9);
19353 if (!SWIG_IsOK(ecode9)) {
19354 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GridRangeSelectEvent" "', expected argument " "9"" of type '" "bool""'");
19355 }
19356 arg9 = static_cast< bool >(val9);
19357 }
19358 if (obj9) {
19359 ecode10 = SWIG_AsVal_bool(obj9, &val10);
19360 if (!SWIG_IsOK(ecode10)) {
19361 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GridRangeSelectEvent" "', expected argument " "10"" of type '" "bool""'");
19362 }
19363 arg10 = static_cast< bool >(val10);
19364 }
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 result = (wxGridRangeSelectEvent *)new wxGridRangeSelectEvent(arg1,arg2,arg3,(wxGridCellCoords const &)*arg4,(wxGridCellCoords const &)*arg5,arg6,arg7,arg8,arg9,arg10);
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_POINTER_NEW | 0 );
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopLeftCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19379 PyObject *resultobj = 0;
19380 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19381 wxGridCellCoords result;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 PyObject *swig_obj[1] ;
19385
19386 if (!args) SWIG_fail;
19387 swig_obj[0] = args;
19388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19389 if (!SWIG_IsOK(res1)) {
19390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopLeftCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19391 }
19392 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19393 {
19394 PyThreadState* __tstate = wxPyBeginAllowThreads();
19395 result = (arg1)->GetTopLeftCoords();
19396 wxPyEndAllowThreads(__tstate);
19397 if (PyErr_Occurred()) SWIG_fail;
19398 }
19399 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19400 return resultobj;
19401 fail:
19402 return NULL;
19403 }
19404
19405
19406 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRightCoords(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19407 PyObject *resultobj = 0;
19408 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19409 wxGridCellCoords result;
19410 void *argp1 = 0 ;
19411 int res1 = 0 ;
19412 PyObject *swig_obj[1] ;
19413
19414 if (!args) SWIG_fail;
19415 swig_obj[0] = args;
19416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19417 if (!SWIG_IsOK(res1)) {
19418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRightCoords" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19419 }
19420 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19421 {
19422 PyThreadState* __tstate = wxPyBeginAllowThreads();
19423 result = (arg1)->GetBottomRightCoords();
19424 wxPyEndAllowThreads(__tstate);
19425 if (PyErr_Occurred()) SWIG_fail;
19426 }
19427 resultobj = SWIG_NewPointerObj((new wxGridCellCoords(static_cast< const wxGridCellCoords& >(result))), SWIGTYPE_p_wxGridCellCoords, SWIG_POINTER_OWN | 0 );
19428 return resultobj;
19429 fail:
19430 return NULL;
19431 }
19432
19433
19434 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetTopRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19435 PyObject *resultobj = 0;
19436 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19437 int result;
19438 void *argp1 = 0 ;
19439 int res1 = 0 ;
19440 PyObject *swig_obj[1] ;
19441
19442 if (!args) SWIG_fail;
19443 swig_obj[0] = args;
19444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19445 if (!SWIG_IsOK(res1)) {
19446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetTopRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19447 }
19448 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19449 {
19450 PyThreadState* __tstate = wxPyBeginAllowThreads();
19451 result = (int)(arg1)->GetTopRow();
19452 wxPyEndAllowThreads(__tstate);
19453 if (PyErr_Occurred()) SWIG_fail;
19454 }
19455 resultobj = SWIG_From_int(static_cast< int >(result));
19456 return resultobj;
19457 fail:
19458 return NULL;
19459 }
19460
19461
19462 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetBottomRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19463 PyObject *resultobj = 0;
19464 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19465 int result;
19466 void *argp1 = 0 ;
19467 int res1 = 0 ;
19468 PyObject *swig_obj[1] ;
19469
19470 if (!args) SWIG_fail;
19471 swig_obj[0] = args;
19472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19473 if (!SWIG_IsOK(res1)) {
19474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetBottomRow" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19475 }
19476 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19477 {
19478 PyThreadState* __tstate = wxPyBeginAllowThreads();
19479 result = (int)(arg1)->GetBottomRow();
19480 wxPyEndAllowThreads(__tstate);
19481 if (PyErr_Occurred()) SWIG_fail;
19482 }
19483 resultobj = SWIG_From_int(static_cast< int >(result));
19484 return resultobj;
19485 fail:
19486 return NULL;
19487 }
19488
19489
19490 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetLeftCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19491 PyObject *resultobj = 0;
19492 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19493 int result;
19494 void *argp1 = 0 ;
19495 int res1 = 0 ;
19496 PyObject *swig_obj[1] ;
19497
19498 if (!args) SWIG_fail;
19499 swig_obj[0] = args;
19500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19501 if (!SWIG_IsOK(res1)) {
19502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetLeftCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19503 }
19504 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 result = (int)(arg1)->GetLeftCol();
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_From_int(static_cast< int >(result));
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_GetRightCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19519 PyObject *resultobj = 0;
19520 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19521 int result;
19522 void *argp1 = 0 ;
19523 int res1 = 0 ;
19524 PyObject *swig_obj[1] ;
19525
19526 if (!args) SWIG_fail;
19527 swig_obj[0] = args;
19528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19529 if (!SWIG_IsOK(res1)) {
19530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_GetRightCol" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19531 }
19532 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19533 {
19534 PyThreadState* __tstate = wxPyBeginAllowThreads();
19535 result = (int)(arg1)->GetRightCol();
19536 wxPyEndAllowThreads(__tstate);
19537 if (PyErr_Occurred()) SWIG_fail;
19538 }
19539 resultobj = SWIG_From_int(static_cast< int >(result));
19540 return resultobj;
19541 fail:
19542 return NULL;
19543 }
19544
19545
19546 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_Selecting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19547 PyObject *resultobj = 0;
19548 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19549 bool result;
19550 void *argp1 = 0 ;
19551 int res1 = 0 ;
19552 PyObject *swig_obj[1] ;
19553
19554 if (!args) SWIG_fail;
19555 swig_obj[0] = args;
19556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19557 if (!SWIG_IsOK(res1)) {
19558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_Selecting" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19559 }
19560 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19561 {
19562 PyThreadState* __tstate = wxPyBeginAllowThreads();
19563 result = (bool)(arg1)->Selecting();
19564 wxPyEndAllowThreads(__tstate);
19565 if (PyErr_Occurred()) SWIG_fail;
19566 }
19567 {
19568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19569 }
19570 return resultobj;
19571 fail:
19572 return NULL;
19573 }
19574
19575
19576 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19577 PyObject *resultobj = 0;
19578 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19579 bool result;
19580 void *argp1 = 0 ;
19581 int res1 = 0 ;
19582 PyObject *swig_obj[1] ;
19583
19584 if (!args) SWIG_fail;
19585 swig_obj[0] = args;
19586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19587 if (!SWIG_IsOK(res1)) {
19588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ControlDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19589 }
19590 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19591 {
19592 PyThreadState* __tstate = wxPyBeginAllowThreads();
19593 result = (bool)(arg1)->ControlDown();
19594 wxPyEndAllowThreads(__tstate);
19595 if (PyErr_Occurred()) SWIG_fail;
19596 }
19597 {
19598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19599 }
19600 return resultobj;
19601 fail:
19602 return NULL;
19603 }
19604
19605
19606 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19607 PyObject *resultobj = 0;
19608 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19609 bool result;
19610 void *argp1 = 0 ;
19611 int res1 = 0 ;
19612 PyObject *swig_obj[1] ;
19613
19614 if (!args) SWIG_fail;
19615 swig_obj[0] = args;
19616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19617 if (!SWIG_IsOK(res1)) {
19618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_MetaDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19619 }
19620 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19621 {
19622 PyThreadState* __tstate = wxPyBeginAllowThreads();
19623 result = (bool)(arg1)->MetaDown();
19624 wxPyEndAllowThreads(__tstate);
19625 if (PyErr_Occurred()) SWIG_fail;
19626 }
19627 {
19628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19629 }
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19637 PyObject *resultobj = 0;
19638 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19639 bool result;
19640 void *argp1 = 0 ;
19641 int res1 = 0 ;
19642 PyObject *swig_obj[1] ;
19643
19644 if (!args) SWIG_fail;
19645 swig_obj[0] = args;
19646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19647 if (!SWIG_IsOK(res1)) {
19648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_ShiftDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19649 }
19650 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 result = (bool)(arg1)->ShiftDown();
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 {
19658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19659 }
19660 return resultobj;
19661 fail:
19662 return NULL;
19663 }
19664
19665
19666 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19667 PyObject *resultobj = 0;
19668 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19669 bool result;
19670 void *argp1 = 0 ;
19671 int res1 = 0 ;
19672 PyObject *swig_obj[1] ;
19673
19674 if (!args) SWIG_fail;
19675 swig_obj[0] = args;
19676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19677 if (!SWIG_IsOK(res1)) {
19678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_AltDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19679 }
19680 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19681 {
19682 PyThreadState* __tstate = wxPyBeginAllowThreads();
19683 result = (bool)(arg1)->AltDown();
19684 wxPyEndAllowThreads(__tstate);
19685 if (PyErr_Occurred()) SWIG_fail;
19686 }
19687 {
19688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19689 }
19690 return resultobj;
19691 fail:
19692 return NULL;
19693 }
19694
19695
19696 SWIGINTERN PyObject *_wrap_GridRangeSelectEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19697 PyObject *resultobj = 0;
19698 wxGridRangeSelectEvent *arg1 = (wxGridRangeSelectEvent *) 0 ;
19699 bool result;
19700 void *argp1 = 0 ;
19701 int res1 = 0 ;
19702 PyObject *swig_obj[1] ;
19703
19704 if (!args) SWIG_fail;
19705 swig_obj[0] = args;
19706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridRangeSelectEvent, 0 | 0 );
19707 if (!SWIG_IsOK(res1)) {
19708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridRangeSelectEvent_CmdDown" "', expected argument " "1"" of type '" "wxGridRangeSelectEvent *""'");
19709 }
19710 arg1 = reinterpret_cast< wxGridRangeSelectEvent * >(argp1);
19711 {
19712 PyThreadState* __tstate = wxPyBeginAllowThreads();
19713 result = (bool)(arg1)->CmdDown();
19714 wxPyEndAllowThreads(__tstate);
19715 if (PyErr_Occurred()) SWIG_fail;
19716 }
19717 {
19718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19719 }
19720 return resultobj;
19721 fail:
19722 return NULL;
19723 }
19724
19725
19726 SWIGINTERN PyObject *GridRangeSelectEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19727 PyObject *obj;
19728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19729 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridRangeSelectEvent, SWIG_NewClientData(obj));
19730 return SWIG_Py_Void();
19731 }
19732
19733 SWIGINTERN PyObject *GridRangeSelectEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19734 return SWIG_Python_InitShadowInstance(args);
19735 }
19736
19737 SWIGINTERN PyObject *_wrap_new_GridEditorCreatedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj = 0;
19739 int arg1 ;
19740 wxEventType arg2 ;
19741 wxObject *arg3 = (wxObject *) 0 ;
19742 int arg4 ;
19743 int arg5 ;
19744 wxControl *arg6 = (wxControl *) 0 ;
19745 wxGridEditorCreatedEvent *result = 0 ;
19746 int val1 ;
19747 int ecode1 = 0 ;
19748 int val2 ;
19749 int ecode2 = 0 ;
19750 void *argp3 = 0 ;
19751 int res3 = 0 ;
19752 int val4 ;
19753 int ecode4 = 0 ;
19754 int val5 ;
19755 int ecode5 = 0 ;
19756 void *argp6 = 0 ;
19757 int res6 = 0 ;
19758 PyObject * obj0 = 0 ;
19759 PyObject * obj1 = 0 ;
19760 PyObject * obj2 = 0 ;
19761 PyObject * obj3 = 0 ;
19762 PyObject * obj4 = 0 ;
19763 PyObject * obj5 = 0 ;
19764 char * kwnames[] = {
19765 (char *) "id",(char *) "type",(char *) "obj",(char *) "row",(char *) "col",(char *) "ctrl", NULL
19766 };
19767
19768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:new_GridEditorCreatedEvent",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
19769 ecode1 = SWIG_AsVal_int(obj0, &val1);
19770 if (!SWIG_IsOK(ecode1)) {
19771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "1"" of type '" "int""'");
19772 }
19773 arg1 = static_cast< int >(val1);
19774 ecode2 = SWIG_AsVal_int(obj1, &val2);
19775 if (!SWIG_IsOK(ecode2)) {
19776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "2"" of type '" "wxEventType""'");
19777 }
19778 arg2 = static_cast< wxEventType >(val2);
19779 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
19780 if (!SWIG_IsOK(res3)) {
19781 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "3"" of type '" "wxObject *""'");
19782 }
19783 arg3 = reinterpret_cast< wxObject * >(argp3);
19784 ecode4 = SWIG_AsVal_int(obj3, &val4);
19785 if (!SWIG_IsOK(ecode4)) {
19786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "4"" of type '" "int""'");
19787 }
19788 arg4 = static_cast< int >(val4);
19789 ecode5 = SWIG_AsVal_int(obj4, &val5);
19790 if (!SWIG_IsOK(ecode5)) {
19791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "5"" of type '" "int""'");
19792 }
19793 arg5 = static_cast< int >(val5);
19794 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxControl, 0 | 0 );
19795 if (!SWIG_IsOK(res6)) {
19796 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_GridEditorCreatedEvent" "', expected argument " "6"" of type '" "wxControl *""'");
19797 }
19798 arg6 = reinterpret_cast< wxControl * >(argp6);
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (wxGridEditorCreatedEvent *)new wxGridEditorCreatedEvent(arg1,arg2,arg3,arg4,arg5,arg6);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_POINTER_NEW | 0 );
19806 return resultobj;
19807 fail:
19808 return NULL;
19809 }
19810
19811
19812 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19813 PyObject *resultobj = 0;
19814 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19815 int result;
19816 void *argp1 = 0 ;
19817 int res1 = 0 ;
19818 PyObject *swig_obj[1] ;
19819
19820 if (!args) SWIG_fail;
19821 swig_obj[0] = args;
19822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19825 }
19826 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (int)(arg1)->GetRow();
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 resultobj = SWIG_From_int(static_cast< int >(result));
19834 return resultobj;
19835 fail:
19836 return NULL;
19837 }
19838
19839
19840 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19841 PyObject *resultobj = 0;
19842 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19843 int result;
19844 void *argp1 = 0 ;
19845 int res1 = 0 ;
19846 PyObject *swig_obj[1] ;
19847
19848 if (!args) SWIG_fail;
19849 swig_obj[0] = args;
19850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19851 if (!SWIG_IsOK(res1)) {
19852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19853 }
19854 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (int)(arg1)->GetCol();
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 resultobj = SWIG_From_int(static_cast< int >(result));
19862 return resultobj;
19863 fail:
19864 return NULL;
19865 }
19866
19867
19868 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_GetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19869 PyObject *resultobj = 0;
19870 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19871 wxControl *result = 0 ;
19872 void *argp1 = 0 ;
19873 int res1 = 0 ;
19874 PyObject *swig_obj[1] ;
19875
19876 if (!args) SWIG_fail;
19877 swig_obj[0] = args;
19878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19879 if (!SWIG_IsOK(res1)) {
19880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_GetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19881 }
19882 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19883 {
19884 PyThreadState* __tstate = wxPyBeginAllowThreads();
19885 result = (wxControl *)(arg1)->GetControl();
19886 wxPyEndAllowThreads(__tstate);
19887 if (PyErr_Occurred()) SWIG_fail;
19888 }
19889 {
19890 resultobj = wxPyMake_wxObject(result, 0);
19891 }
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj = 0;
19900 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19901 int arg2 ;
19902 void *argp1 = 0 ;
19903 int res1 = 0 ;
19904 int val2 ;
19905 int ecode2 = 0 ;
19906 PyObject * obj0 = 0 ;
19907 PyObject * obj1 = 0 ;
19908 char * kwnames[] = {
19909 (char *) "self",(char *) "row", NULL
19910 };
19911
19912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
19913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19914 if (!SWIG_IsOK(res1)) {
19915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19916 }
19917 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19918 ecode2 = SWIG_AsVal_int(obj1, &val2);
19919 if (!SWIG_IsOK(ecode2)) {
19920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetRow" "', expected argument " "2"" of type '" "int""'");
19921 }
19922 arg2 = static_cast< int >(val2);
19923 {
19924 PyThreadState* __tstate = wxPyBeginAllowThreads();
19925 (arg1)->SetRow(arg2);
19926 wxPyEndAllowThreads(__tstate);
19927 if (PyErr_Occurred()) SWIG_fail;
19928 }
19929 resultobj = SWIG_Py_Void();
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj = 0;
19938 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19939 int arg2 ;
19940 void *argp1 = 0 ;
19941 int res1 = 0 ;
19942 int val2 ;
19943 int ecode2 = 0 ;
19944 PyObject * obj0 = 0 ;
19945 PyObject * obj1 = 0 ;
19946 char * kwnames[] = {
19947 (char *) "self",(char *) "col", NULL
19948 };
19949
19950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
19951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19952 if (!SWIG_IsOK(res1)) {
19953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19954 }
19955 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19956 ecode2 = SWIG_AsVal_int(obj1, &val2);
19957 if (!SWIG_IsOK(ecode2)) {
19958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridEditorCreatedEvent_SetCol" "', expected argument " "2"" of type '" "int""'");
19959 }
19960 arg2 = static_cast< int >(val2);
19961 {
19962 PyThreadState* __tstate = wxPyBeginAllowThreads();
19963 (arg1)->SetCol(arg2);
19964 wxPyEndAllowThreads(__tstate);
19965 if (PyErr_Occurred()) SWIG_fail;
19966 }
19967 resultobj = SWIG_Py_Void();
19968 return resultobj;
19969 fail:
19970 return NULL;
19971 }
19972
19973
19974 SWIGINTERN PyObject *_wrap_GridEditorCreatedEvent_SetControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19975 PyObject *resultobj = 0;
19976 wxGridEditorCreatedEvent *arg1 = (wxGridEditorCreatedEvent *) 0 ;
19977 wxControl *arg2 = (wxControl *) 0 ;
19978 void *argp1 = 0 ;
19979 int res1 = 0 ;
19980 void *argp2 = 0 ;
19981 int res2 = 0 ;
19982 PyObject * obj0 = 0 ;
19983 PyObject * obj1 = 0 ;
19984 char * kwnames[] = {
19985 (char *) "self",(char *) "ctrl", NULL
19986 };
19987
19988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridEditorCreatedEvent_SetControl",kwnames,&obj0,&obj1)) SWIG_fail;
19989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridEditorCreatedEvent, 0 | 0 );
19990 if (!SWIG_IsOK(res1)) {
19991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "1"" of type '" "wxGridEditorCreatedEvent *""'");
19992 }
19993 arg1 = reinterpret_cast< wxGridEditorCreatedEvent * >(argp1);
19994 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxControl, 0 | 0 );
19995 if (!SWIG_IsOK(res2)) {
19996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridEditorCreatedEvent_SetControl" "', expected argument " "2"" of type '" "wxControl *""'");
19997 }
19998 arg2 = reinterpret_cast< wxControl * >(argp2);
19999 {
20000 PyThreadState* __tstate = wxPyBeginAllowThreads();
20001 (arg1)->SetControl(arg2);
20002 wxPyEndAllowThreads(__tstate);
20003 if (PyErr_Occurred()) SWIG_fail;
20004 }
20005 resultobj = SWIG_Py_Void();
20006 return resultobj;
20007 fail:
20008 return NULL;
20009 }
20010
20011
20012 SWIGINTERN PyObject *GridEditorCreatedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20013 PyObject *obj;
20014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20015 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridEditorCreatedEvent, SWIG_NewClientData(obj));
20016 return SWIG_Py_Void();
20017 }
20018
20019 SWIGINTERN PyObject *GridEditorCreatedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20020 return SWIG_Python_InitShadowInstance(args);
20021 }
20022
20023 static PyMethodDef SwigMethods[] = {
20024 { (char *)"GridCellWorker__setOORInfo", (PyCFunction) _wrap_GridCellWorker__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20025 { (char *)"delete_GridCellWorker", (PyCFunction)_wrap_delete_GridCellWorker, METH_O, NULL},
20026 { (char *)"GridCellWorker_SetParameters", (PyCFunction) _wrap_GridCellWorker_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20027 { (char *)"GridCellWorker_IncRef", (PyCFunction)_wrap_GridCellWorker_IncRef, METH_O, NULL},
20028 { (char *)"GridCellWorker_DecRef", (PyCFunction)_wrap_GridCellWorker_DecRef, METH_O, NULL},
20029 { (char *)"GridCellWorker_swigregister", GridCellWorker_swigregister, METH_VARARGS, NULL},
20030 { (char *)"GridCellRenderer_swigregister", GridCellRenderer_swigregister, METH_VARARGS, NULL},
20031 { (char *)"new_PyGridCellRenderer", (PyCFunction)_wrap_new_PyGridCellRenderer, METH_NOARGS, NULL},
20032 { (char *)"PyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_PyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20033 { (char *)"PyGridCellRenderer_SetParameters", (PyCFunction) _wrap_PyGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20034 { (char *)"PyGridCellRenderer_swigregister", PyGridCellRenderer_swigregister, METH_VARARGS, NULL},
20035 { (char *)"PyGridCellRenderer_swiginit", PyGridCellRenderer_swiginit, METH_VARARGS, NULL},
20036 { (char *)"new_GridCellStringRenderer", (PyCFunction)_wrap_new_GridCellStringRenderer, METH_NOARGS, NULL},
20037 { (char *)"GridCellStringRenderer_swigregister", GridCellStringRenderer_swigregister, METH_VARARGS, NULL},
20038 { (char *)"GridCellStringRenderer_swiginit", GridCellStringRenderer_swiginit, METH_VARARGS, NULL},
20039 { (char *)"new_GridCellNumberRenderer", (PyCFunction)_wrap_new_GridCellNumberRenderer, METH_NOARGS, NULL},
20040 { (char *)"GridCellNumberRenderer_swigregister", GridCellNumberRenderer_swigregister, METH_VARARGS, NULL},
20041 { (char *)"GridCellNumberRenderer_swiginit", GridCellNumberRenderer_swiginit, METH_VARARGS, NULL},
20042 { (char *)"new_GridCellFloatRenderer", (PyCFunction) _wrap_new_GridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20043 { (char *)"GridCellFloatRenderer_GetWidth", (PyCFunction)_wrap_GridCellFloatRenderer_GetWidth, METH_O, NULL},
20044 { (char *)"GridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_GridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20045 { (char *)"GridCellFloatRenderer_GetPrecision", (PyCFunction)_wrap_GridCellFloatRenderer_GetPrecision, METH_O, NULL},
20046 { (char *)"GridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_GridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS, NULL},
20047 { (char *)"GridCellFloatRenderer_swigregister", GridCellFloatRenderer_swigregister, METH_VARARGS, NULL},
20048 { (char *)"GridCellFloatRenderer_swiginit", GridCellFloatRenderer_swiginit, METH_VARARGS, NULL},
20049 { (char *)"new_GridCellBoolRenderer", (PyCFunction)_wrap_new_GridCellBoolRenderer, METH_NOARGS, NULL},
20050 { (char *)"GridCellBoolRenderer_swigregister", GridCellBoolRenderer_swigregister, METH_VARARGS, NULL},
20051 { (char *)"GridCellBoolRenderer_swiginit", GridCellBoolRenderer_swiginit, METH_VARARGS, NULL},
20052 { (char *)"new_GridCellDateTimeRenderer", (PyCFunction) _wrap_new_GridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20053 { (char *)"GridCellDateTimeRenderer_swigregister", GridCellDateTimeRenderer_swigregister, METH_VARARGS, NULL},
20054 { (char *)"GridCellDateTimeRenderer_swiginit", GridCellDateTimeRenderer_swiginit, METH_VARARGS, NULL},
20055 { (char *)"new_GridCellEnumRenderer", (PyCFunction) _wrap_new_GridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20056 { (char *)"GridCellEnumRenderer_swigregister", GridCellEnumRenderer_swigregister, METH_VARARGS, NULL},
20057 { (char *)"GridCellEnumRenderer_swiginit", GridCellEnumRenderer_swiginit, METH_VARARGS, NULL},
20058 { (char *)"new_GridCellAutoWrapStringRenderer", (PyCFunction)_wrap_new_GridCellAutoWrapStringRenderer, METH_NOARGS, NULL},
20059 { (char *)"GridCellAutoWrapStringRenderer_swigregister", GridCellAutoWrapStringRenderer_swigregister, METH_VARARGS, NULL},
20060 { (char *)"GridCellAutoWrapStringRenderer_swiginit", GridCellAutoWrapStringRenderer_swiginit, METH_VARARGS, NULL},
20061 { (char *)"GridCellEditor_IsCreated", (PyCFunction)_wrap_GridCellEditor_IsCreated, METH_O, NULL},
20062 { (char *)"GridCellEditor_GetControl", (PyCFunction)_wrap_GridCellEditor_GetControl, METH_O, NULL},
20063 { (char *)"GridCellEditor_SetControl", (PyCFunction) _wrap_GridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20064 { (char *)"GridCellEditor_GetCellAttr", (PyCFunction)_wrap_GridCellEditor_GetCellAttr, METH_O, NULL},
20065 { (char *)"GridCellEditor_SetCellAttr", (PyCFunction) _wrap_GridCellEditor_SetCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20066 { (char *)"GridCellEditor_Create", (PyCFunction) _wrap_GridCellEditor_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20067 { (char *)"GridCellEditor_BeginEdit", (PyCFunction) _wrap_GridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20068 { (char *)"GridCellEditor_EndEdit", (PyCFunction) _wrap_GridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS, NULL},
20069 { (char *)"GridCellEditor_Reset", (PyCFunction)_wrap_GridCellEditor_Reset, METH_O, NULL},
20070 { (char *)"GridCellEditor_Clone", (PyCFunction)_wrap_GridCellEditor_Clone, METH_O, NULL},
20071 { (char *)"GridCellEditor_SetSize", (PyCFunction) _wrap_GridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20072 { (char *)"GridCellEditor_Show", (PyCFunction) _wrap_GridCellEditor_Show, METH_VARARGS | METH_KEYWORDS, NULL},
20073 { (char *)"GridCellEditor_PaintBackground", (PyCFunction) _wrap_GridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20074 { (char *)"GridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_GridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS, NULL},
20075 { (char *)"GridCellEditor_StartingKey", (PyCFunction) _wrap_GridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS, NULL},
20076 { (char *)"GridCellEditor_StartingClick", (PyCFunction)_wrap_GridCellEditor_StartingClick, METH_O, NULL},
20077 { (char *)"GridCellEditor_HandleReturn", (PyCFunction) _wrap_GridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS, NULL},
20078 { (char *)"GridCellEditor_Destroy", (PyCFunction)_wrap_GridCellEditor_Destroy, METH_O, NULL},
20079 { (char *)"GridCellEditor_swigregister", GridCellEditor_swigregister, METH_VARARGS, NULL},
20080 { (char *)"new_PyGridCellEditor", (PyCFunction)_wrap_new_PyGridCellEditor, METH_NOARGS, NULL},
20081 { (char *)"PyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_PyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20082 { (char *)"PyGridCellEditor_SetParameters", (PyCFunction) _wrap_PyGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS, NULL},
20083 { (char *)"PyGridCellEditor_swigregister", PyGridCellEditor_swigregister, METH_VARARGS, NULL},
20084 { (char *)"PyGridCellEditor_swiginit", PyGridCellEditor_swiginit, METH_VARARGS, NULL},
20085 { (char *)"new_GridCellTextEditor", (PyCFunction)_wrap_new_GridCellTextEditor, METH_NOARGS, NULL},
20086 { (char *)"GridCellTextEditor_GetValue", (PyCFunction)_wrap_GridCellTextEditor_GetValue, METH_O, NULL},
20087 { (char *)"GridCellTextEditor_swigregister", GridCellTextEditor_swigregister, METH_VARARGS, NULL},
20088 { (char *)"GridCellTextEditor_swiginit", GridCellTextEditor_swiginit, METH_VARARGS, NULL},
20089 { (char *)"new_GridCellNumberEditor", (PyCFunction) _wrap_new_GridCellNumberEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20090 { (char *)"GridCellNumberEditor_swigregister", GridCellNumberEditor_swigregister, METH_VARARGS, NULL},
20091 { (char *)"GridCellNumberEditor_swiginit", GridCellNumberEditor_swiginit, METH_VARARGS, NULL},
20092 { (char *)"new_GridCellFloatEditor", (PyCFunction) _wrap_new_GridCellFloatEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20093 { (char *)"GridCellFloatEditor_swigregister", GridCellFloatEditor_swigregister, METH_VARARGS, NULL},
20094 { (char *)"GridCellFloatEditor_swiginit", GridCellFloatEditor_swiginit, METH_VARARGS, NULL},
20095 { (char *)"new_GridCellBoolEditor", (PyCFunction)_wrap_new_GridCellBoolEditor, METH_NOARGS, NULL},
20096 { (char *)"GridCellBoolEditor_GetValue", (PyCFunction)_wrap_GridCellBoolEditor_GetValue, METH_O, NULL},
20097 { (char *)"GridCellBoolEditor_swigregister", GridCellBoolEditor_swigregister, METH_VARARGS, NULL},
20098 { (char *)"GridCellBoolEditor_swiginit", GridCellBoolEditor_swiginit, METH_VARARGS, NULL},
20099 { (char *)"new_GridCellChoiceEditor", (PyCFunction) _wrap_new_GridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20100 { (char *)"GridCellChoiceEditor_GetValue", (PyCFunction)_wrap_GridCellChoiceEditor_GetValue, METH_O, NULL},
20101 { (char *)"GridCellChoiceEditor_swigregister", GridCellChoiceEditor_swigregister, METH_VARARGS, NULL},
20102 { (char *)"GridCellChoiceEditor_swiginit", GridCellChoiceEditor_swiginit, METH_VARARGS, NULL},
20103 { (char *)"new_GridCellEnumEditor", (PyCFunction) _wrap_new_GridCellEnumEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20104 { (char *)"GridCellEnumEditor_swigregister", GridCellEnumEditor_swigregister, METH_VARARGS, NULL},
20105 { (char *)"GridCellEnumEditor_swiginit", GridCellEnumEditor_swiginit, METH_VARARGS, NULL},
20106 { (char *)"new_GridCellAutoWrapStringEditor", (PyCFunction)_wrap_new_GridCellAutoWrapStringEditor, METH_NOARGS, NULL},
20107 { (char *)"GridCellAutoWrapStringEditor_swigregister", GridCellAutoWrapStringEditor_swigregister, METH_VARARGS, NULL},
20108 { (char *)"GridCellAutoWrapStringEditor_swiginit", GridCellAutoWrapStringEditor_swiginit, METH_VARARGS, NULL},
20109 { (char *)"GridCellAttr__setOORInfo", (PyCFunction) _wrap_GridCellAttr__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20110 { (char *)"new_GridCellAttr", (PyCFunction) _wrap_new_GridCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20111 { (char *)"delete_GridCellAttr", (PyCFunction)_wrap_delete_GridCellAttr, METH_O, NULL},
20112 { (char *)"GridCellAttr_Clone", (PyCFunction)_wrap_GridCellAttr_Clone, METH_O, NULL},
20113 { (char *)"GridCellAttr_MergeWith", (PyCFunction) _wrap_GridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS, NULL},
20114 { (char *)"GridCellAttr_IncRef", (PyCFunction)_wrap_GridCellAttr_IncRef, METH_O, NULL},
20115 { (char *)"GridCellAttr_DecRef", (PyCFunction)_wrap_GridCellAttr_DecRef, METH_O, NULL},
20116 { (char *)"GridCellAttr_SetTextColour", (PyCFunction) _wrap_GridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20117 { (char *)"GridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_GridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20118 { (char *)"GridCellAttr_SetFont", (PyCFunction) _wrap_GridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20119 { (char *)"GridCellAttr_SetAlignment", (PyCFunction) _wrap_GridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20120 { (char *)"GridCellAttr_SetSize", (PyCFunction) _wrap_GridCellAttr_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20121 { (char *)"GridCellAttr_SetOverflow", (PyCFunction) _wrap_GridCellAttr_SetOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20122 { (char *)"GridCellAttr_SetReadOnly", (PyCFunction) _wrap_GridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20123 { (char *)"GridCellAttr_SetRenderer", (PyCFunction) _wrap_GridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20124 { (char *)"GridCellAttr_SetEditor", (PyCFunction) _wrap_GridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20125 { (char *)"GridCellAttr_SetKind", (PyCFunction) _wrap_GridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
20126 { (char *)"GridCellAttr_HasTextColour", (PyCFunction)_wrap_GridCellAttr_HasTextColour, METH_O, NULL},
20127 { (char *)"GridCellAttr_HasBackgroundColour", (PyCFunction)_wrap_GridCellAttr_HasBackgroundColour, METH_O, NULL},
20128 { (char *)"GridCellAttr_HasFont", (PyCFunction)_wrap_GridCellAttr_HasFont, METH_O, NULL},
20129 { (char *)"GridCellAttr_HasAlignment", (PyCFunction)_wrap_GridCellAttr_HasAlignment, METH_O, NULL},
20130 { (char *)"GridCellAttr_HasRenderer", (PyCFunction)_wrap_GridCellAttr_HasRenderer, METH_O, NULL},
20131 { (char *)"GridCellAttr_HasEditor", (PyCFunction)_wrap_GridCellAttr_HasEditor, METH_O, NULL},
20132 { (char *)"GridCellAttr_HasReadWriteMode", (PyCFunction)_wrap_GridCellAttr_HasReadWriteMode, METH_O, NULL},
20133 { (char *)"GridCellAttr_HasOverflowMode", (PyCFunction)_wrap_GridCellAttr_HasOverflowMode, METH_O, NULL},
20134 { (char *)"GridCellAttr_GetTextColour", (PyCFunction)_wrap_GridCellAttr_GetTextColour, METH_O, NULL},
20135 { (char *)"GridCellAttr_GetBackgroundColour", (PyCFunction)_wrap_GridCellAttr_GetBackgroundColour, METH_O, NULL},
20136 { (char *)"GridCellAttr_GetFont", (PyCFunction)_wrap_GridCellAttr_GetFont, METH_O, NULL},
20137 { (char *)"GridCellAttr_GetAlignment", (PyCFunction)_wrap_GridCellAttr_GetAlignment, METH_O, NULL},
20138 { (char *)"GridCellAttr_GetSize", (PyCFunction)_wrap_GridCellAttr_GetSize, METH_O, NULL},
20139 { (char *)"GridCellAttr_GetOverflow", (PyCFunction)_wrap_GridCellAttr_GetOverflow, METH_O, NULL},
20140 { (char *)"GridCellAttr_GetRenderer", (PyCFunction) _wrap_GridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20141 { (char *)"GridCellAttr_GetEditor", (PyCFunction) _wrap_GridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20142 { (char *)"GridCellAttr_IsReadOnly", (PyCFunction)_wrap_GridCellAttr_IsReadOnly, METH_O, NULL},
20143 { (char *)"GridCellAttr_GetKind", (PyCFunction)_wrap_GridCellAttr_GetKind, METH_O, NULL},
20144 { (char *)"GridCellAttr_SetDefAttr", (PyCFunction) _wrap_GridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20145 { (char *)"GridCellAttr_swigregister", GridCellAttr_swigregister, METH_VARARGS, NULL},
20146 { (char *)"GridCellAttr_swiginit", GridCellAttr_swiginit, METH_VARARGS, NULL},
20147 { (char *)"new_GridCellAttrProvider", (PyCFunction)_wrap_new_GridCellAttrProvider, METH_NOARGS, NULL},
20148 { (char *)"GridCellAttrProvider__setOORInfo", (PyCFunction) _wrap_GridCellAttrProvider__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20149 { (char *)"GridCellAttrProvider_GetAttr", (PyCFunction) _wrap_GridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20150 { (char *)"GridCellAttrProvider_SetAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20151 { (char *)"GridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20152 { (char *)"GridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_GridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20153 { (char *)"GridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS, NULL},
20154 { (char *)"GridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_GridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS, NULL},
20155 { (char *)"GridCellAttrProvider_swigregister", GridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20156 { (char *)"GridCellAttrProvider_swiginit", GridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20157 { (char *)"new_PyGridCellAttrProvider", (PyCFunction)_wrap_new_PyGridCellAttrProvider, METH_NOARGS, NULL},
20158 { (char *)"PyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_PyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20159 { (char *)"PyGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20160 { (char *)"PyGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20161 { (char *)"PyGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20162 { (char *)"PyGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_PyGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20163 { (char *)"PyGridCellAttrProvider_swigregister", PyGridCellAttrProvider_swigregister, METH_VARARGS, NULL},
20164 { (char *)"PyGridCellAttrProvider_swiginit", PyGridCellAttrProvider_swiginit, METH_VARARGS, NULL},
20165 { (char *)"delete_GridTableBase", (PyCFunction)_wrap_delete_GridTableBase, METH_O, NULL},
20166 { (char *)"GridTableBase__setOORInfo", (PyCFunction) _wrap_GridTableBase__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20167 { (char *)"GridTableBase_SetAttrProvider", (PyCFunction) _wrap_GridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS, NULL},
20168 { (char *)"GridTableBase_GetAttrProvider", (PyCFunction)_wrap_GridTableBase_GetAttrProvider, METH_O, NULL},
20169 { (char *)"GridTableBase_SetView", (PyCFunction) _wrap_GridTableBase_SetView, METH_VARARGS | METH_KEYWORDS, NULL},
20170 { (char *)"GridTableBase_GetView", (PyCFunction)_wrap_GridTableBase_GetView, METH_O, NULL},
20171 { (char *)"GridTableBase_GetNumberRows", (PyCFunction)_wrap_GridTableBase_GetNumberRows, METH_O, NULL},
20172 { (char *)"GridTableBase_GetNumberCols", (PyCFunction)_wrap_GridTableBase_GetNumberCols, METH_O, NULL},
20173 { (char *)"GridTableBase_IsEmptyCell", (PyCFunction) _wrap_GridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS, NULL},
20174 { (char *)"GridTableBase_GetValue", (PyCFunction) _wrap_GridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20175 { (char *)"GridTableBase_SetValue", (PyCFunction) _wrap_GridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
20176 { (char *)"GridTableBase_GetTypeName", (PyCFunction) _wrap_GridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS, NULL},
20177 { (char *)"GridTableBase_CanGetValueAs", (PyCFunction) _wrap_GridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20178 { (char *)"GridTableBase_CanSetValueAs", (PyCFunction) _wrap_GridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS, NULL},
20179 { (char *)"GridTableBase_GetValueAsLong", (PyCFunction) _wrap_GridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20180 { (char *)"GridTableBase_GetValueAsDouble", (PyCFunction) _wrap_GridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20181 { (char *)"GridTableBase_GetValueAsBool", (PyCFunction) _wrap_GridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20182 { (char *)"GridTableBase_SetValueAsLong", (PyCFunction) _wrap_GridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS, NULL},
20183 { (char *)"GridTableBase_SetValueAsDouble", (PyCFunction) _wrap_GridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS, NULL},
20184 { (char *)"GridTableBase_SetValueAsBool", (PyCFunction) _wrap_GridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS, NULL},
20185 { (char *)"GridTableBase_Clear", (PyCFunction)_wrap_GridTableBase_Clear, METH_O, NULL},
20186 { (char *)"GridTableBase_InsertRows", (PyCFunction) _wrap_GridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20187 { (char *)"GridTableBase_AppendRows", (PyCFunction) _wrap_GridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20188 { (char *)"GridTableBase_DeleteRows", (PyCFunction) _wrap_GridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20189 { (char *)"GridTableBase_InsertCols", (PyCFunction) _wrap_GridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20190 { (char *)"GridTableBase_AppendCols", (PyCFunction) _wrap_GridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20191 { (char *)"GridTableBase_DeleteCols", (PyCFunction) _wrap_GridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20192 { (char *)"GridTableBase_GetRowLabelValue", (PyCFunction) _wrap_GridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20193 { (char *)"GridTableBase_GetColLabelValue", (PyCFunction) _wrap_GridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20194 { (char *)"GridTableBase_SetRowLabelValue", (PyCFunction) _wrap_GridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20195 { (char *)"GridTableBase_SetColLabelValue", (PyCFunction) _wrap_GridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20196 { (char *)"GridTableBase_CanHaveAttributes", (PyCFunction)_wrap_GridTableBase_CanHaveAttributes, METH_O, NULL},
20197 { (char *)"GridTableBase_GetAttr", (PyCFunction) _wrap_GridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20198 { (char *)"GridTableBase_SetAttr", (PyCFunction) _wrap_GridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20199 { (char *)"GridTableBase_SetRowAttr", (PyCFunction) _wrap_GridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20200 { (char *)"GridTableBase_SetColAttr", (PyCFunction) _wrap_GridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20201 { (char *)"GridTableBase_swigregister", GridTableBase_swigregister, METH_VARARGS, NULL},
20202 { (char *)"new_PyGridTableBase", (PyCFunction)_wrap_new_PyGridTableBase, METH_NOARGS, NULL},
20203 { (char *)"PyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_PyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20204 { (char *)"PyGridTableBase_Destroy", (PyCFunction)_wrap_PyGridTableBase_Destroy, METH_O, NULL},
20205 { (char *)"PyGridTableBase_swigregister", PyGridTableBase_swigregister, METH_VARARGS, NULL},
20206 { (char *)"PyGridTableBase_swiginit", PyGridTableBase_swiginit, METH_VARARGS, NULL},
20207 { (char *)"new_GridStringTable", (PyCFunction) _wrap_new_GridStringTable, METH_VARARGS | METH_KEYWORDS, NULL},
20208 { (char *)"GridStringTable_swigregister", GridStringTable_swigregister, METH_VARARGS, NULL},
20209 { (char *)"GridStringTable_swiginit", GridStringTable_swiginit, METH_VARARGS, NULL},
20210 { (char *)"new_GridTableMessage", (PyCFunction) _wrap_new_GridTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20211 { (char *)"delete_GridTableMessage", (PyCFunction)_wrap_delete_GridTableMessage, METH_O, NULL},
20212 { (char *)"GridTableMessage_SetTableObject", (PyCFunction) _wrap_GridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS, NULL},
20213 { (char *)"GridTableMessage_GetTableObject", (PyCFunction)_wrap_GridTableMessage_GetTableObject, METH_O, NULL},
20214 { (char *)"GridTableMessage_SetId", (PyCFunction) _wrap_GridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
20215 { (char *)"GridTableMessage_GetId", (PyCFunction)_wrap_GridTableMessage_GetId, METH_O, NULL},
20216 { (char *)"GridTableMessage_SetCommandInt", (PyCFunction) _wrap_GridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS, NULL},
20217 { (char *)"GridTableMessage_GetCommandInt", (PyCFunction)_wrap_GridTableMessage_GetCommandInt, METH_O, NULL},
20218 { (char *)"GridTableMessage_SetCommandInt2", (PyCFunction) _wrap_GridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS, NULL},
20219 { (char *)"GridTableMessage_GetCommandInt2", (PyCFunction)_wrap_GridTableMessage_GetCommandInt2, METH_O, NULL},
20220 { (char *)"GridTableMessage_swigregister", GridTableMessage_swigregister, METH_VARARGS, NULL},
20221 { (char *)"GridTableMessage_swiginit", GridTableMessage_swiginit, METH_VARARGS, NULL},
20222 { (char *)"new_GridCellCoords", (PyCFunction) _wrap_new_GridCellCoords, METH_VARARGS | METH_KEYWORDS, NULL},
20223 { (char *)"delete_GridCellCoords", (PyCFunction)_wrap_delete_GridCellCoords, METH_O, NULL},
20224 { (char *)"GridCellCoords_GetRow", (PyCFunction)_wrap_GridCellCoords_GetRow, METH_O, NULL},
20225 { (char *)"GridCellCoords_SetRow", (PyCFunction) _wrap_GridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20226 { (char *)"GridCellCoords_GetCol", (PyCFunction)_wrap_GridCellCoords_GetCol, METH_O, NULL},
20227 { (char *)"GridCellCoords_SetCol", (PyCFunction) _wrap_GridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20228 { (char *)"GridCellCoords_Set", (PyCFunction) _wrap_GridCellCoords_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20229 { (char *)"GridCellCoords___eq__", (PyCFunction) _wrap_GridCellCoords___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20230 { (char *)"GridCellCoords___ne__", (PyCFunction) _wrap_GridCellCoords___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20231 { (char *)"GridCellCoords_Get", (PyCFunction)_wrap_GridCellCoords_Get, METH_O, NULL},
20232 { (char *)"GridCellCoords_swigregister", GridCellCoords_swigregister, METH_VARARGS, NULL},
20233 { (char *)"GridCellCoords_swiginit", GridCellCoords_swiginit, METH_VARARGS, NULL},
20234 { (char *)"new_Grid", (PyCFunction) _wrap_new_Grid, METH_VARARGS | METH_KEYWORDS, NULL},
20235 { (char *)"new_PreGrid", (PyCFunction)_wrap_new_PreGrid, METH_NOARGS, NULL},
20236 { (char *)"Grid_Create", (PyCFunction) _wrap_Grid_Create, METH_VARARGS | METH_KEYWORDS, NULL},
20237 { (char *)"Grid_CreateGrid", (PyCFunction) _wrap_Grid_CreateGrid, METH_VARARGS | METH_KEYWORDS, NULL},
20238 { (char *)"Grid_SetSelectionMode", (PyCFunction) _wrap_Grid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS, NULL},
20239 { (char *)"Grid_GetSelectionMode", (PyCFunction)_wrap_Grid_GetSelectionMode, METH_O, NULL},
20240 { (char *)"Grid_GetNumberRows", (PyCFunction)_wrap_Grid_GetNumberRows, METH_O, NULL},
20241 { (char *)"Grid_GetNumberCols", (PyCFunction)_wrap_Grid_GetNumberCols, METH_O, NULL},
20242 { (char *)"Grid_ProcessTableMessage", (PyCFunction) _wrap_Grid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS, NULL},
20243 { (char *)"Grid_GetTable", (PyCFunction)_wrap_Grid_GetTable, METH_O, NULL},
20244 { (char *)"Grid_SetTable", (PyCFunction) _wrap_Grid_SetTable, METH_VARARGS | METH_KEYWORDS, NULL},
20245 { (char *)"Grid_ClearGrid", (PyCFunction)_wrap_Grid_ClearGrid, METH_O, NULL},
20246 { (char *)"Grid_InsertRows", (PyCFunction) _wrap_Grid_InsertRows, METH_VARARGS | METH_KEYWORDS, NULL},
20247 { (char *)"Grid_AppendRows", (PyCFunction) _wrap_Grid_AppendRows, METH_VARARGS | METH_KEYWORDS, NULL},
20248 { (char *)"Grid_DeleteRows", (PyCFunction) _wrap_Grid_DeleteRows, METH_VARARGS | METH_KEYWORDS, NULL},
20249 { (char *)"Grid_InsertCols", (PyCFunction) _wrap_Grid_InsertCols, METH_VARARGS | METH_KEYWORDS, NULL},
20250 { (char *)"Grid_AppendCols", (PyCFunction) _wrap_Grid_AppendCols, METH_VARARGS | METH_KEYWORDS, NULL},
20251 { (char *)"Grid_DeleteCols", (PyCFunction) _wrap_Grid_DeleteCols, METH_VARARGS | METH_KEYWORDS, NULL},
20252 { (char *)"Grid_DrawCellHighlight", (PyCFunction) _wrap_Grid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS, NULL},
20253 { (char *)"Grid_DrawTextRectangle", (PyCFunction) _wrap_Grid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20254 { (char *)"Grid_GetTextBoxSize", (PyCFunction) _wrap_Grid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS, NULL},
20255 { (char *)"Grid_BeginBatch", (PyCFunction)_wrap_Grid_BeginBatch, METH_O, NULL},
20256 { (char *)"Grid_EndBatch", (PyCFunction)_wrap_Grid_EndBatch, METH_O, NULL},
20257 { (char *)"Grid_GetBatchCount", (PyCFunction)_wrap_Grid_GetBatchCount, METH_O, NULL},
20258 { (char *)"Grid_ForceRefresh", (PyCFunction)_wrap_Grid_ForceRefresh, METH_O, NULL},
20259 { (char *)"Grid_IsEditable", (PyCFunction)_wrap_Grid_IsEditable, METH_O, NULL},
20260 { (char *)"Grid_EnableEditing", (PyCFunction) _wrap_Grid_EnableEditing, METH_VARARGS | METH_KEYWORDS, NULL},
20261 { (char *)"Grid_EnableCellEditControl", (PyCFunction) _wrap_Grid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS, NULL},
20262 { (char *)"Grid_DisableCellEditControl", (PyCFunction)_wrap_Grid_DisableCellEditControl, METH_O, NULL},
20263 { (char *)"Grid_CanEnableCellControl", (PyCFunction)_wrap_Grid_CanEnableCellControl, METH_O, NULL},
20264 { (char *)"Grid_IsCellEditControlEnabled", (PyCFunction)_wrap_Grid_IsCellEditControlEnabled, METH_O, NULL},
20265 { (char *)"Grid_IsCellEditControlShown", (PyCFunction)_wrap_Grid_IsCellEditControlShown, METH_O, NULL},
20266 { (char *)"Grid_IsCurrentCellReadOnly", (PyCFunction)_wrap_Grid_IsCurrentCellReadOnly, METH_O, NULL},
20267 { (char *)"Grid_ShowCellEditControl", (PyCFunction)_wrap_Grid_ShowCellEditControl, METH_O, NULL},
20268 { (char *)"Grid_HideCellEditControl", (PyCFunction)_wrap_Grid_HideCellEditControl, METH_O, NULL},
20269 { (char *)"Grid_SaveEditControlValue", (PyCFunction)_wrap_Grid_SaveEditControlValue, METH_O, NULL},
20270 { (char *)"Grid_XYToCell", (PyCFunction) _wrap_Grid_XYToCell, METH_VARARGS | METH_KEYWORDS, NULL},
20271 { (char *)"Grid_YToRow", (PyCFunction) _wrap_Grid_YToRow, METH_VARARGS | METH_KEYWORDS, NULL},
20272 { (char *)"Grid_XToCol", (PyCFunction) _wrap_Grid_XToCol, METH_VARARGS | METH_KEYWORDS, NULL},
20273 { (char *)"Grid_YToEdgeOfRow", (PyCFunction) _wrap_Grid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS, NULL},
20274 { (char *)"Grid_XToEdgeOfCol", (PyCFunction) _wrap_Grid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS, NULL},
20275 { (char *)"Grid_CellToRect", (PyCFunction) _wrap_Grid_CellToRect, METH_VARARGS | METH_KEYWORDS, NULL},
20276 { (char *)"Grid_GetGridCursorRow", (PyCFunction)_wrap_Grid_GetGridCursorRow, METH_O, NULL},
20277 { (char *)"Grid_GetGridCursorCol", (PyCFunction)_wrap_Grid_GetGridCursorCol, METH_O, NULL},
20278 { (char *)"Grid_IsVisible", (PyCFunction) _wrap_Grid_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20279 { (char *)"Grid_MakeCellVisible", (PyCFunction) _wrap_Grid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20280 { (char *)"Grid_SetGridCursor", (PyCFunction) _wrap_Grid_SetGridCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20281 { (char *)"Grid_MoveCursorUp", (PyCFunction) _wrap_Grid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS, NULL},
20282 { (char *)"Grid_MoveCursorDown", (PyCFunction) _wrap_Grid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS, NULL},
20283 { (char *)"Grid_MoveCursorLeft", (PyCFunction) _wrap_Grid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS, NULL},
20284 { (char *)"Grid_MoveCursorRight", (PyCFunction) _wrap_Grid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS, NULL},
20285 { (char *)"Grid_MovePageDown", (PyCFunction)_wrap_Grid_MovePageDown, METH_O, NULL},
20286 { (char *)"Grid_MovePageUp", (PyCFunction)_wrap_Grid_MovePageUp, METH_O, NULL},
20287 { (char *)"Grid_MoveCursorUpBlock", (PyCFunction) _wrap_Grid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20288 { (char *)"Grid_MoveCursorDownBlock", (PyCFunction) _wrap_Grid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20289 { (char *)"Grid_MoveCursorLeftBlock", (PyCFunction) _wrap_Grid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20290 { (char *)"Grid_MoveCursorRightBlock", (PyCFunction) _wrap_Grid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20291 { (char *)"Grid_GetDefaultRowLabelSize", (PyCFunction)_wrap_Grid_GetDefaultRowLabelSize, METH_O, NULL},
20292 { (char *)"Grid_GetRowLabelSize", (PyCFunction)_wrap_Grid_GetRowLabelSize, METH_O, NULL},
20293 { (char *)"Grid_GetDefaultColLabelSize", (PyCFunction)_wrap_Grid_GetDefaultColLabelSize, METH_O, NULL},
20294 { (char *)"Grid_GetColLabelSize", (PyCFunction)_wrap_Grid_GetColLabelSize, METH_O, NULL},
20295 { (char *)"Grid_GetLabelBackgroundColour", (PyCFunction)_wrap_Grid_GetLabelBackgroundColour, METH_O, NULL},
20296 { (char *)"Grid_GetLabelTextColour", (PyCFunction)_wrap_Grid_GetLabelTextColour, METH_O, NULL},
20297 { (char *)"Grid_GetLabelFont", (PyCFunction)_wrap_Grid_GetLabelFont, METH_O, NULL},
20298 { (char *)"Grid_GetRowLabelAlignment", (PyCFunction)_wrap_Grid_GetRowLabelAlignment, METH_O, NULL},
20299 { (char *)"Grid_GetColLabelAlignment", (PyCFunction)_wrap_Grid_GetColLabelAlignment, METH_O, NULL},
20300 { (char *)"Grid_GetColLabelTextOrientation", (PyCFunction)_wrap_Grid_GetColLabelTextOrientation, METH_O, NULL},
20301 { (char *)"Grid_GetRowLabelValue", (PyCFunction) _wrap_Grid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20302 { (char *)"Grid_GetColLabelValue", (PyCFunction) _wrap_Grid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20303 { (char *)"Grid_GetGridLineColour", (PyCFunction)_wrap_Grid_GetGridLineColour, METH_O, NULL},
20304 { (char *)"Grid_GetCellHighlightColour", (PyCFunction)_wrap_Grid_GetCellHighlightColour, METH_O, NULL},
20305 { (char *)"Grid_GetCellHighlightPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightPenWidth, METH_O, NULL},
20306 { (char *)"Grid_GetCellHighlightROPenWidth", (PyCFunction)_wrap_Grid_GetCellHighlightROPenWidth, METH_O, NULL},
20307 { (char *)"Grid_SetRowLabelSize", (PyCFunction) _wrap_Grid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20308 { (char *)"Grid_SetColLabelSize", (PyCFunction) _wrap_Grid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20309 { (char *)"Grid_SetLabelBackgroundColour", (PyCFunction) _wrap_Grid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20310 { (char *)"Grid_SetLabelTextColour", (PyCFunction) _wrap_Grid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20311 { (char *)"Grid_SetLabelFont", (PyCFunction) _wrap_Grid_SetLabelFont, METH_VARARGS | METH_KEYWORDS, NULL},
20312 { (char *)"Grid_SetRowLabelAlignment", (PyCFunction) _wrap_Grid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20313 { (char *)"Grid_SetColLabelAlignment", (PyCFunction) _wrap_Grid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20314 { (char *)"Grid_SetColLabelTextOrientation", (PyCFunction) _wrap_Grid_SetColLabelTextOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20315 { (char *)"Grid_SetRowLabelValue", (PyCFunction) _wrap_Grid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20316 { (char *)"Grid_SetColLabelValue", (PyCFunction) _wrap_Grid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS, NULL},
20317 { (char *)"Grid_SetGridLineColour", (PyCFunction) _wrap_Grid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS, NULL},
20318 { (char *)"Grid_SetCellHighlightColour", (PyCFunction) _wrap_Grid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20319 { (char *)"Grid_SetCellHighlightPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20320 { (char *)"Grid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_Grid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20321 { (char *)"Grid_EnableDragRowSize", (PyCFunction) _wrap_Grid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20322 { (char *)"Grid_DisableDragRowSize", (PyCFunction)_wrap_Grid_DisableDragRowSize, METH_O, NULL},
20323 { (char *)"Grid_CanDragRowSize", (PyCFunction)_wrap_Grid_CanDragRowSize, METH_O, NULL},
20324 { (char *)"Grid_EnableDragColSize", (PyCFunction) _wrap_Grid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20325 { (char *)"Grid_DisableDragColSize", (PyCFunction)_wrap_Grid_DisableDragColSize, METH_O, NULL},
20326 { (char *)"Grid_CanDragColSize", (PyCFunction)_wrap_Grid_CanDragColSize, METH_O, NULL},
20327 { (char *)"Grid_EnableDragGridSize", (PyCFunction) _wrap_Grid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS, NULL},
20328 { (char *)"Grid_DisableDragGridSize", (PyCFunction)_wrap_Grid_DisableDragGridSize, METH_O, NULL},
20329 { (char *)"Grid_CanDragGridSize", (PyCFunction)_wrap_Grid_CanDragGridSize, METH_O, NULL},
20330 { (char *)"Grid_EnableDragCell", (PyCFunction) _wrap_Grid_EnableDragCell, METH_VARARGS | METH_KEYWORDS, NULL},
20331 { (char *)"Grid_DisableDragCell", (PyCFunction)_wrap_Grid_DisableDragCell, METH_O, NULL},
20332 { (char *)"Grid_CanDragCell", (PyCFunction)_wrap_Grid_CanDragCell, METH_O, NULL},
20333 { (char *)"Grid_SetAttr", (PyCFunction) _wrap_Grid_SetAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20334 { (char *)"Grid_SetRowAttr", (PyCFunction) _wrap_Grid_SetRowAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20335 { (char *)"Grid_SetColAttr", (PyCFunction) _wrap_Grid_SetColAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20336 { (char *)"Grid_GetOrCreateCellAttr", (PyCFunction) _wrap_Grid_GetOrCreateCellAttr, METH_VARARGS | METH_KEYWORDS, NULL},
20337 { (char *)"Grid_SetColFormatBool", (PyCFunction) _wrap_Grid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS, NULL},
20338 { (char *)"Grid_SetColFormatNumber", (PyCFunction) _wrap_Grid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS, NULL},
20339 { (char *)"Grid_SetColFormatFloat", (PyCFunction) _wrap_Grid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS, NULL},
20340 { (char *)"Grid_SetColFormatCustom", (PyCFunction) _wrap_Grid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS, NULL},
20341 { (char *)"Grid_EnableGridLines", (PyCFunction) _wrap_Grid_EnableGridLines, METH_VARARGS | METH_KEYWORDS, NULL},
20342 { (char *)"Grid_GridLinesEnabled", (PyCFunction)_wrap_Grid_GridLinesEnabled, METH_O, NULL},
20343 { (char *)"Grid_GetDefaultRowSize", (PyCFunction)_wrap_Grid_GetDefaultRowSize, METH_O, NULL},
20344 { (char *)"Grid_GetRowSize", (PyCFunction) _wrap_Grid_GetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20345 { (char *)"Grid_GetDefaultColSize", (PyCFunction)_wrap_Grid_GetDefaultColSize, METH_O, NULL},
20346 { (char *)"Grid_GetColSize", (PyCFunction) _wrap_Grid_GetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20347 { (char *)"Grid_GetDefaultCellBackgroundColour", (PyCFunction)_wrap_Grid_GetDefaultCellBackgroundColour, METH_O, NULL},
20348 { (char *)"Grid_GetCellBackgroundColour", (PyCFunction) _wrap_Grid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20349 { (char *)"Grid_GetDefaultCellTextColour", (PyCFunction)_wrap_Grid_GetDefaultCellTextColour, METH_O, NULL},
20350 { (char *)"Grid_GetCellTextColour", (PyCFunction) _wrap_Grid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20351 { (char *)"Grid_GetDefaultCellFont", (PyCFunction)_wrap_Grid_GetDefaultCellFont, METH_O, NULL},
20352 { (char *)"Grid_GetCellFont", (PyCFunction) _wrap_Grid_GetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20353 { (char *)"Grid_GetDefaultCellAlignment", (PyCFunction)_wrap_Grid_GetDefaultCellAlignment, METH_O, NULL},
20354 { (char *)"Grid_GetCellAlignment", (PyCFunction) _wrap_Grid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20355 { (char *)"Grid_GetDefaultCellOverflow", (PyCFunction)_wrap_Grid_GetDefaultCellOverflow, METH_O, NULL},
20356 { (char *)"Grid_GetCellOverflow", (PyCFunction) _wrap_Grid_GetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20357 { (char *)"Grid_GetCellSize", (PyCFunction) _wrap_Grid_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20358 { (char *)"Grid_SetDefaultRowSize", (PyCFunction) _wrap_Grid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20359 { (char *)"Grid_SetRowSize", (PyCFunction) _wrap_Grid_SetRowSize, METH_VARARGS | METH_KEYWORDS, NULL},
20360 { (char *)"Grid_SetDefaultColSize", (PyCFunction) _wrap_Grid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20361 { (char *)"Grid_SetColSize", (PyCFunction) _wrap_Grid_SetColSize, METH_VARARGS | METH_KEYWORDS, NULL},
20362 { (char *)"Grid_AutoSizeColumn", (PyCFunction) _wrap_Grid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS, NULL},
20363 { (char *)"Grid_AutoSizeRow", (PyCFunction) _wrap_Grid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS, NULL},
20364 { (char *)"Grid_AutoSizeColumns", (PyCFunction) _wrap_Grid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS, NULL},
20365 { (char *)"Grid_AutoSizeRows", (PyCFunction) _wrap_Grid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS, NULL},
20366 { (char *)"Grid_AutoSize", (PyCFunction)_wrap_Grid_AutoSize, METH_O, NULL},
20367 { (char *)"Grid_AutoSizeRowLabelSize", (PyCFunction) _wrap_Grid_AutoSizeRowLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20368 { (char *)"Grid_AutoSizeColLabelSize", (PyCFunction) _wrap_Grid_AutoSizeColLabelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20369 { (char *)"Grid_SetColMinimalWidth", (PyCFunction) _wrap_Grid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20370 { (char *)"Grid_SetRowMinimalHeight", (PyCFunction) _wrap_Grid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20371 { (char *)"Grid_SetColMinimalAcceptableWidth", (PyCFunction) _wrap_Grid_SetColMinimalAcceptableWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20372 { (char *)"Grid_SetRowMinimalAcceptableHeight", (PyCFunction) _wrap_Grid_SetRowMinimalAcceptableHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20373 { (char *)"Grid_GetColMinimalAcceptableWidth", (PyCFunction)_wrap_Grid_GetColMinimalAcceptableWidth, METH_O, NULL},
20374 { (char *)"Grid_GetRowMinimalAcceptableHeight", (PyCFunction)_wrap_Grid_GetRowMinimalAcceptableHeight, METH_O, NULL},
20375 { (char *)"Grid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_Grid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20376 { (char *)"Grid_SetCellBackgroundColour", (PyCFunction) _wrap_Grid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
20377 { (char *)"Grid_SetDefaultCellTextColour", (PyCFunction) _wrap_Grid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20378 { (char *)"Grid_SetCellTextColour", (PyCFunction) _wrap_Grid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
20379 { (char *)"Grid_SetDefaultCellFont", (PyCFunction) _wrap_Grid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20380 { (char *)"Grid_SetCellFont", (PyCFunction) _wrap_Grid_SetCellFont, METH_VARARGS | METH_KEYWORDS, NULL},
20381 { (char *)"Grid_SetDefaultCellAlignment", (PyCFunction) _wrap_Grid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20382 { (char *)"Grid_SetCellAlignment", (PyCFunction) _wrap_Grid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS, NULL},
20383 { (char *)"Grid_SetDefaultCellOverflow", (PyCFunction) _wrap_Grid_SetDefaultCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20384 { (char *)"Grid_SetCellOverflow", (PyCFunction) _wrap_Grid_SetCellOverflow, METH_VARARGS | METH_KEYWORDS, NULL},
20385 { (char *)"Grid_SetCellSize", (PyCFunction) _wrap_Grid_SetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
20386 { (char *)"Grid_SetDefaultRenderer", (PyCFunction) _wrap_Grid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"Grid_SetCellRenderer", (PyCFunction) _wrap_Grid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20388 { (char *)"Grid_GetDefaultRenderer", (PyCFunction)_wrap_Grid_GetDefaultRenderer, METH_O, NULL},
20389 { (char *)"Grid_GetCellRenderer", (PyCFunction) _wrap_Grid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"Grid_SetDefaultEditor", (PyCFunction) _wrap_Grid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20391 { (char *)"Grid_SetCellEditor", (PyCFunction) _wrap_Grid_SetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20392 { (char *)"Grid_GetDefaultEditor", (PyCFunction)_wrap_Grid_GetDefaultEditor, METH_O, NULL},
20393 { (char *)"Grid_GetCellEditor", (PyCFunction) _wrap_Grid_GetCellEditor, METH_VARARGS | METH_KEYWORDS, NULL},
20394 { (char *)"Grid_GetCellValue", (PyCFunction) _wrap_Grid_GetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20395 { (char *)"Grid_SetCellValue", (PyCFunction) _wrap_Grid_SetCellValue, METH_VARARGS | METH_KEYWORDS, NULL},
20396 { (char *)"Grid_IsReadOnly", (PyCFunction) _wrap_Grid_IsReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20397 { (char *)"Grid_SetReadOnly", (PyCFunction) _wrap_Grid_SetReadOnly, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"Grid_SelectRow", (PyCFunction) _wrap_Grid_SelectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"Grid_SelectCol", (PyCFunction) _wrap_Grid_SelectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"Grid_SelectBlock", (PyCFunction) _wrap_Grid_SelectBlock, METH_VARARGS | METH_KEYWORDS, NULL},
20401 { (char *)"Grid_SelectAll", (PyCFunction)_wrap_Grid_SelectAll, METH_O, NULL},
20402 { (char *)"Grid_IsSelection", (PyCFunction)_wrap_Grid_IsSelection, METH_O, NULL},
20403 { (char *)"Grid_ClearSelection", (PyCFunction)_wrap_Grid_ClearSelection, METH_O, NULL},
20404 { (char *)"Grid_IsInSelection", (PyCFunction) _wrap_Grid_IsInSelection, METH_VARARGS | METH_KEYWORDS, NULL},
20405 { (char *)"Grid_GetSelectedCells", (PyCFunction)_wrap_Grid_GetSelectedCells, METH_O, NULL},
20406 { (char *)"Grid_GetSelectionBlockTopLeft", (PyCFunction)_wrap_Grid_GetSelectionBlockTopLeft, METH_O, NULL},
20407 { (char *)"Grid_GetSelectionBlockBottomRight", (PyCFunction)_wrap_Grid_GetSelectionBlockBottomRight, METH_O, NULL},
20408 { (char *)"Grid_GetSelectedRows", (PyCFunction)_wrap_Grid_GetSelectedRows, METH_O, NULL},
20409 { (char *)"Grid_GetSelectedCols", (PyCFunction)_wrap_Grid_GetSelectedCols, METH_O, NULL},
20410 { (char *)"Grid_DeselectRow", (PyCFunction) _wrap_Grid_DeselectRow, METH_VARARGS | METH_KEYWORDS, NULL},
20411 { (char *)"Grid_DeselectCol", (PyCFunction) _wrap_Grid_DeselectCol, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"Grid_DeselectCell", (PyCFunction) _wrap_Grid_DeselectCell, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"Grid_BlockToDeviceRect", (PyCFunction) _wrap_Grid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"Grid_GetSelectionBackground", (PyCFunction)_wrap_Grid_GetSelectionBackground, METH_O, NULL},
20415 { (char *)"Grid_GetSelectionForeground", (PyCFunction)_wrap_Grid_GetSelectionForeground, METH_O, NULL},
20416 { (char *)"Grid_SetSelectionBackground", (PyCFunction) _wrap_Grid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"Grid_SetSelectionForeground", (PyCFunction) _wrap_Grid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"Grid_RegisterDataType", (PyCFunction) _wrap_Grid_RegisterDataType, METH_VARARGS | METH_KEYWORDS, NULL},
20419 { (char *)"Grid_GetDefaultEditorForCell", (PyCFunction) _wrap_Grid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"Grid_GetDefaultRendererForCell", (PyCFunction) _wrap_Grid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"Grid_GetDefaultEditorForType", (PyCFunction) _wrap_Grid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS, NULL},
20422 { (char *)"Grid_GetDefaultRendererForType", (PyCFunction) _wrap_Grid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS, NULL},
20423 { (char *)"Grid_SetMargins", (PyCFunction) _wrap_Grid_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},
20424 { (char *)"Grid_GetGridWindow", (PyCFunction)_wrap_Grid_GetGridWindow, METH_O, NULL},
20425 { (char *)"Grid_GetGridRowLabelWindow", (PyCFunction)_wrap_Grid_GetGridRowLabelWindow, METH_O, NULL},
20426 { (char *)"Grid_GetGridColLabelWindow", (PyCFunction)_wrap_Grid_GetGridColLabelWindow, METH_O, NULL},
20427 { (char *)"Grid_GetGridCornerLabelWindow", (PyCFunction)_wrap_Grid_GetGridCornerLabelWindow, METH_O, NULL},
20428 { (char *)"Grid_SetScrollLineX", (PyCFunction) _wrap_Grid_SetScrollLineX, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"Grid_SetScrollLineY", (PyCFunction) _wrap_Grid_SetScrollLineY, METH_VARARGS | METH_KEYWORDS, NULL},
20430 { (char *)"Grid_GetScrollLineX", (PyCFunction)_wrap_Grid_GetScrollLineX, METH_O, NULL},
20431 { (char *)"Grid_GetScrollLineY", (PyCFunction)_wrap_Grid_GetScrollLineY, METH_O, NULL},
20432 { (char *)"Grid_GetScrollX", (PyCFunction) _wrap_Grid_GetScrollX, METH_VARARGS | METH_KEYWORDS, NULL},
20433 { (char *)"Grid_GetScrollY", (PyCFunction) _wrap_Grid_GetScrollY, METH_VARARGS | METH_KEYWORDS, NULL},
20434 { (char *)"Grid_GetClassDefaultAttributes", (PyCFunction) _wrap_Grid_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
20435 { (char *)"Grid_swigregister", Grid_swigregister, METH_VARARGS, NULL},
20436 { (char *)"Grid_swiginit", Grid_swiginit, METH_VARARGS, NULL},
20437 { (char *)"new_GridEvent", (PyCFunction) _wrap_new_GridEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20438 { (char *)"GridEvent_GetRow", (PyCFunction)_wrap_GridEvent_GetRow, METH_O, NULL},
20439 { (char *)"GridEvent_GetCol", (PyCFunction)_wrap_GridEvent_GetCol, METH_O, NULL},
20440 { (char *)"GridEvent_GetPosition", (PyCFunction)_wrap_GridEvent_GetPosition, METH_O, NULL},
20441 { (char *)"GridEvent_Selecting", (PyCFunction)_wrap_GridEvent_Selecting, METH_O, NULL},
20442 { (char *)"GridEvent_ControlDown", (PyCFunction)_wrap_GridEvent_ControlDown, METH_O, NULL},
20443 { (char *)"GridEvent_MetaDown", (PyCFunction)_wrap_GridEvent_MetaDown, METH_O, NULL},
20444 { (char *)"GridEvent_ShiftDown", (PyCFunction)_wrap_GridEvent_ShiftDown, METH_O, NULL},
20445 { (char *)"GridEvent_AltDown", (PyCFunction)_wrap_GridEvent_AltDown, METH_O, NULL},
20446 { (char *)"GridEvent_CmdDown", (PyCFunction)_wrap_GridEvent_CmdDown, METH_O, NULL},
20447 { (char *)"GridEvent_swigregister", GridEvent_swigregister, METH_VARARGS, NULL},
20448 { (char *)"GridEvent_swiginit", GridEvent_swiginit, METH_VARARGS, NULL},
20449 { (char *)"new_GridSizeEvent", (PyCFunction) _wrap_new_GridSizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20450 { (char *)"GridSizeEvent_GetRowOrCol", (PyCFunction)_wrap_GridSizeEvent_GetRowOrCol, METH_O, NULL},
20451 { (char *)"GridSizeEvent_GetPosition", (PyCFunction)_wrap_GridSizeEvent_GetPosition, METH_O, NULL},
20452 { (char *)"GridSizeEvent_ControlDown", (PyCFunction)_wrap_GridSizeEvent_ControlDown, METH_O, NULL},
20453 { (char *)"GridSizeEvent_MetaDown", (PyCFunction)_wrap_GridSizeEvent_MetaDown, METH_O, NULL},
20454 { (char *)"GridSizeEvent_ShiftDown", (PyCFunction)_wrap_GridSizeEvent_ShiftDown, METH_O, NULL},
20455 { (char *)"GridSizeEvent_AltDown", (PyCFunction)_wrap_GridSizeEvent_AltDown, METH_O, NULL},
20456 { (char *)"GridSizeEvent_CmdDown", (PyCFunction)_wrap_GridSizeEvent_CmdDown, METH_O, NULL},
20457 { (char *)"GridSizeEvent_swigregister", GridSizeEvent_swigregister, METH_VARARGS, NULL},
20458 { (char *)"GridSizeEvent_swiginit", GridSizeEvent_swiginit, METH_VARARGS, NULL},
20459 { (char *)"new_GridRangeSelectEvent", (PyCFunction) _wrap_new_GridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20460 { (char *)"GridRangeSelectEvent_GetTopLeftCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopLeftCoords, METH_O, NULL},
20461 { (char *)"GridRangeSelectEvent_GetBottomRightCoords", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRightCoords, METH_O, NULL},
20462 { (char *)"GridRangeSelectEvent_GetTopRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetTopRow, METH_O, NULL},
20463 { (char *)"GridRangeSelectEvent_GetBottomRow", (PyCFunction)_wrap_GridRangeSelectEvent_GetBottomRow, METH_O, NULL},
20464 { (char *)"GridRangeSelectEvent_GetLeftCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetLeftCol, METH_O, NULL},
20465 { (char *)"GridRangeSelectEvent_GetRightCol", (PyCFunction)_wrap_GridRangeSelectEvent_GetRightCol, METH_O, NULL},
20466 { (char *)"GridRangeSelectEvent_Selecting", (PyCFunction)_wrap_GridRangeSelectEvent_Selecting, METH_O, NULL},
20467 { (char *)"GridRangeSelectEvent_ControlDown", (PyCFunction)_wrap_GridRangeSelectEvent_ControlDown, METH_O, NULL},
20468 { (char *)"GridRangeSelectEvent_MetaDown", (PyCFunction)_wrap_GridRangeSelectEvent_MetaDown, METH_O, NULL},
20469 { (char *)"GridRangeSelectEvent_ShiftDown", (PyCFunction)_wrap_GridRangeSelectEvent_ShiftDown, METH_O, NULL},
20470 { (char *)"GridRangeSelectEvent_AltDown", (PyCFunction)_wrap_GridRangeSelectEvent_AltDown, METH_O, NULL},
20471 { (char *)"GridRangeSelectEvent_CmdDown", (PyCFunction)_wrap_GridRangeSelectEvent_CmdDown, METH_O, NULL},
20472 { (char *)"GridRangeSelectEvent_swigregister", GridRangeSelectEvent_swigregister, METH_VARARGS, NULL},
20473 { (char *)"GridRangeSelectEvent_swiginit", GridRangeSelectEvent_swiginit, METH_VARARGS, NULL},
20474 { (char *)"new_GridEditorCreatedEvent", (PyCFunction) _wrap_new_GridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
20475 { (char *)"GridEditorCreatedEvent_GetRow", (PyCFunction)_wrap_GridEditorCreatedEvent_GetRow, METH_O, NULL},
20476 { (char *)"GridEditorCreatedEvent_GetCol", (PyCFunction)_wrap_GridEditorCreatedEvent_GetCol, METH_O, NULL},
20477 { (char *)"GridEditorCreatedEvent_GetControl", (PyCFunction)_wrap_GridEditorCreatedEvent_GetControl, METH_O, NULL},
20478 { (char *)"GridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_GridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
20479 { (char *)"GridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_GridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"GridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_GridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"GridEditorCreatedEvent_swigregister", GridEditorCreatedEvent_swigregister, METH_VARARGS, NULL},
20482 { (char *)"GridEditorCreatedEvent_swiginit", GridEditorCreatedEvent_swiginit, METH_VARARGS, NULL},
20483 { NULL, NULL, 0, NULL }
20484 };
20485
20486
20487 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20488
20489 static void *_p_wxPyGridCellRendererTo_p_wxGridCellRenderer(void *x) {
20490 return (void *)((wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20491 }
20492 static void *_p_wxGridCellStringRendererTo_p_wxGridCellRenderer(void *x) {
20493 return (void *)((wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20494 }
20495 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellRenderer(void *x) {
20496 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20497 }
20498 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellRenderer(void *x) {
20499 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20500 }
20501 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellRenderer(void *x) {
20502 return (void *)((wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20503 }
20504 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellRenderer(void *x) {
20505 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20506 }
20507 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellRenderer(void *x) {
20508 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20509 }
20510 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellRenderer(void *x) {
20511 return (void *)((wxGridCellRenderer *) (wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20512 }
20513 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellStringRenderer(void *x) {
20514 return (void *)((wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20515 }
20516 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellStringRenderer(void *x) {
20517 return (void *)((wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20518 }
20519 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellStringRenderer(void *x) {
20520 return (void *)((wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20521 }
20522 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellStringRenderer(void *x) {
20523 return (void *)((wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20524 }
20525 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellStringRenderer(void *x) {
20526 return (void *)((wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20527 }
20528 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellWorker(void *x) {
20529 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
20530 }
20531 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellWorker(void *x) {
20532 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
20533 }
20534 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellWorker(void *x) {
20535 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
20536 }
20537 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellWorker(void *x) {
20538 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
20539 }
20540 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellWorker(void *x) {
20541 return (void *)((wxGridCellWorker *) (wxGridCellEditor *)(wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
20542 }
20543 static void *_p_wxGridCellTextEditorTo_p_wxGridCellWorker(void *x) {
20544 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellTextEditor *) x));
20545 }
20546 static void *_p_wxPyGridCellEditorTo_p_wxGridCellWorker(void *x) {
20547 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxPyGridCellEditor *) x));
20548 }
20549 static void *_p_wxGridCellEditorTo_p_wxGridCellWorker(void *x) {
20550 return (void *)((wxGridCellWorker *) ((wxGridCellEditor *) x));
20551 }
20552 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellWorker(void *x) {
20553 return (void *)((wxGridCellWorker *) (wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
20554 }
20555 static void *_p_wxGridCellAutoWrapStringRendererTo_p_wxGridCellWorker(void *x) {
20556 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellAutoWrapStringRenderer *) x));
20557 }
20558 static void *_p_wxGridCellEnumRendererTo_p_wxGridCellWorker(void *x) {
20559 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellEnumRenderer *) x));
20560 }
20561 static void *_p_wxGridCellDateTimeRendererTo_p_wxGridCellWorker(void *x) {
20562 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellDateTimeRenderer *) x));
20563 }
20564 static void *_p_wxGridCellBoolRendererTo_p_wxGridCellWorker(void *x) {
20565 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellBoolRenderer *) x));
20566 }
20567 static void *_p_wxGridCellFloatRendererTo_p_wxGridCellWorker(void *x) {
20568 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellFloatRenderer *) x));
20569 }
20570 static void *_p_wxGridCellNumberRendererTo_p_wxGridCellWorker(void *x) {
20571 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *)(wxGridCellStringRenderer *) ((wxGridCellNumberRenderer *) x));
20572 }
20573 static void *_p_wxGridCellStringRendererTo_p_wxGridCellWorker(void *x) {
20574 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxGridCellStringRenderer *) x));
20575 }
20576 static void *_p_wxPyGridCellRendererTo_p_wxGridCellWorker(void *x) {
20577 return (void *)((wxGridCellWorker *) (wxGridCellRenderer *) ((wxPyGridCellRenderer *) x));
20578 }
20579 static void *_p_wxGridCellRendererTo_p_wxGridCellWorker(void *x) {
20580 return (void *)((wxGridCellWorker *) ((wxGridCellRenderer *) x));
20581 }
20582 static void *_p_wxScrolledWindowTo_p_wxPanel(void *x) {
20583 return (void *)((wxPanel *) ((wxScrolledWindow *) x));
20584 }
20585 static void *_p_wxPyVScrolledWindowTo_p_wxPanel(void *x) {
20586 return (void *)((wxPanel *) ((wxPyVScrolledWindow *) x));
20587 }
20588 static void *_p_wxPyScrolledWindowTo_p_wxPanel(void *x) {
20589 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20590 }
20591 static void *_p_wxGridTo_p_wxPanel(void *x) {
20592 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxGrid *) x));
20593 }
20594 static void *_p_wxPyVListBoxTo_p_wxPanel(void *x) {
20595 return (void *)((wxPanel *) (wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20596 }
20597 static void *_p_wxPyHtmlListBoxTo_p_wxPanel(void *x) {
20598 return (void *)((wxPanel *) (wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20599 }
20600 static void *_p_wxPyPanelTo_p_wxPanel(void *x) {
20601 return (void *)((wxPanel *) ((wxPyPanel *) x));
20602 }
20603 static void *_p_wxPreviewCanvasTo_p_wxPanel(void *x) {
20604 return (void *)((wxPanel *) (wxScrolledWindow *) ((wxPreviewCanvas *) x));
20605 }
20606 static void *_p_wxPreviewControlBarTo_p_wxPanel(void *x) {
20607 return (void *)((wxPanel *) ((wxPreviewControlBar *) x));
20608 }
20609 static void *_p_wxPyPreviewControlBarTo_p_wxPanel(void *x) {
20610 return (void *)((wxPanel *) (wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20611 }
20612 static void *_p_wxGridSizeEventTo_p_wxNotifyEvent(void *x) {
20613 return (void *)((wxNotifyEvent *) ((wxGridSizeEvent *) x));
20614 }
20615 static void *_p_wxGridRangeSelectEventTo_p_wxNotifyEvent(void *x) {
20616 return (void *)((wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20617 }
20618 static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {
20619 return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));
20620 }
20621 static void *_p_wxGridEventTo_p_wxNotifyEvent(void *x) {
20622 return (void *)((wxNotifyEvent *) ((wxGridEvent *) x));
20623 }
20624 static void *_p_wxPyScrolledWindowTo_p_wxScrolledWindow(void *x) {
20625 return (void *)((wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20626 }
20627 static void *_p_wxGridTo_p_wxScrolledWindow(void *x) {
20628 return (void *)((wxScrolledWindow *) ((wxGrid *) x));
20629 }
20630 static void *_p_wxPreviewCanvasTo_p_wxScrolledWindow(void *x) {
20631 return (void *)((wxScrolledWindow *) ((wxPreviewCanvas *) x));
20632 }
20633 static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {
20634 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
20635 }
20636 static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {
20637 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
20638 }
20639 static void *_p_wxPyPanelTo_p_wxWindow(void *x) {
20640 return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));
20641 }
20642 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
20643 return (void *)((wxWindow *) ((wxMenuBar *) x));
20644 }
20645 static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {
20646 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
20647 }
20648 static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {
20649 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
20650 }
20651 static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {
20652 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
20653 }
20654 static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {
20655 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
20656 }
20657 static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {
20658 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
20659 }
20660 static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {
20661 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
20662 }
20663 static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {
20664 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
20665 }
20666 static void *_p_wxFileDialogTo_p_wxWindow(void *x) {
20667 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
20668 }
20669 static void *_p_wxPanelTo_p_wxWindow(void *x) {
20670 return (void *)((wxWindow *) ((wxPanel *) x));
20671 }
20672 static void *_p_wxStatusBarTo_p_wxWindow(void *x) {
20673 return (void *)((wxWindow *) ((wxStatusBar *) x));
20674 }
20675 static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {
20676 return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));
20677 }
20678 static void *_p_wxTipWindowTo_p_wxWindow(void *x) {
20679 return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
20680 }
20681 static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {
20682 return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
20683 }
20684 static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {
20685 return (void *)((wxWindow *) ((wxPopupWindow *) x));
20686 }
20687 static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {
20688 return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));
20689 }
20690 static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {
20691 return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));
20692 }
20693 static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {
20694 return (void *)((wxWindow *) ((wxTopLevelWindow *) x));
20695 }
20696 static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {
20697 return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));
20698 }
20699 static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {
20700 return (void *)((wxWindow *) ((wxSplitterWindow *) x));
20701 }
20702 static void *_p_wxSashWindowTo_p_wxWindow(void *x) {
20703 return (void *)((wxWindow *) ((wxSashWindow *) x));
20704 }
20705 static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {
20706 return (void *)((wxWindow *) ((wxMDIClientWindow *) x));
20707 }
20708 static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {
20709 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
20710 }
20711 static void *_p_wxControlTo_p_wxWindow(void *x) {
20712 return (void *)((wxWindow *) ((wxControl *) x));
20713 }
20714 static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {
20715 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20716 }
20717 static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {
20718 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20719 }
20720 static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {
20721 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
20722 }
20723 static void *_p_wxGridTo_p_wxWindow(void *x) {
20724 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
20725 }
20726 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
20727 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
20728 }
20729 static void *_p_wxPyWindowTo_p_wxWindow(void *x) {
20730 return (void *)((wxWindow *) ((wxPyWindow *) x));
20731 }
20732 static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {
20733 return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
20734 }
20735 static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {
20736 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
20737 }
20738 static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {
20739 return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
20740 }
20741 static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {
20742 return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));
20743 }
20744 static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {
20745 return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
20746 }
20747 static void *_p_wxFrameTo_p_wxWindow(void *x) {
20748 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));
20749 }
20750 static void *_p_wxFontDialogTo_p_wxWindow(void *x) {
20751 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
20752 }
20753 static void *_p_wxDirDialogTo_p_wxWindow(void *x) {
20754 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
20755 }
20756 static void *_p_wxColourDialogTo_p_wxWindow(void *x) {
20757 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
20758 }
20759 static void *_p_wxDialogTo_p_wxWindow(void *x) {
20760 return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));
20761 }
20762 static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {
20763 return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
20764 }
20765 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
20766 return (void *)((wxControl *) ((wxControlWithItems *) x));
20767 }
20768 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
20769 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
20770 }
20771 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
20772 return (void *)((wxEvent *) ((wxMenuEvent *) x));
20773 }
20774 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
20775 return (void *)((wxEvent *) ((wxCloseEvent *) x));
20776 }
20777 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
20778 return (void *)((wxEvent *) ((wxMouseEvent *) x));
20779 }
20780 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
20781 return (void *)((wxEvent *) ((wxEraseEvent *) x));
20782 }
20783 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
20784 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
20785 }
20786 static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {
20787 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
20788 }
20789 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
20790 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
20791 }
20792 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
20793 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
20794 }
20795 static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {
20796 return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));
20797 }
20798 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
20799 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
20800 }
20801 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
20802 return (void *)((wxEvent *) ((wxPyEvent *) x));
20803 }
20804 static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {
20805 return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));
20806 }
20807 static void *_p_wxGridRangeSelectEventTo_p_wxEvent(void *x) {
20808 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
20809 }
20810 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
20811 return (void *)((wxEvent *) ((wxIdleEvent *) x));
20812 }
20813 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
20814 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
20815 }
20816 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
20817 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
20818 }
20819 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
20820 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
20821 }
20822 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
20823 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
20824 }
20825 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
20826 return (void *)((wxEvent *) ((wxActivateEvent *) x));
20827 }
20828 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
20829 return (void *)((wxEvent *) ((wxSizeEvent *) x));
20830 }
20831 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
20832 return (void *)((wxEvent *) ((wxMoveEvent *) x));
20833 }
20834 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
20835 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
20836 }
20837 static void *_p_wxGridSizeEventTo_p_wxEvent(void *x) {
20838 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
20839 }
20840 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
20841 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
20842 }
20843 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
20844 return (void *)((wxEvent *) ((wxPaintEvent *) x));
20845 }
20846 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
20847 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
20848 }
20849 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
20850 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
20851 }
20852 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
20853 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
20854 }
20855 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
20856 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
20857 }
20858 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
20859 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
20860 }
20861 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
20862 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
20863 }
20864 static void *_p_wxGridEventTo_p_wxEvent(void *x) {
20865 return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
20866 }
20867 static void *_p_wxGridEditorCreatedEventTo_p_wxEvent(void *x) {
20868 return (void *)((wxEvent *) (wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
20869 }
20870 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
20871 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
20872 }
20873 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
20874 return (void *)((wxEvent *) ((wxFocusEvent *) x));
20875 }
20876 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
20877 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
20878 }
20879 static void *_p_wxSashEventTo_p_wxEvent(void *x) {
20880 return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));
20881 }
20882 static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {
20883 return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));
20884 }
20885 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
20886 return (void *)((wxEvent *) ((wxShowEvent *) x));
20887 }
20888 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
20889 return (void *)((wxEvent *) ((wxCommandEvent *) x));
20890 }
20891 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
20892 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
20893 }
20894 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
20895 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
20896 }
20897 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
20898 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
20899 }
20900 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
20901 return (void *)((wxEvent *) ((wxKeyEvent *) x));
20902 }
20903 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
20904 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
20905 }
20906 static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {
20907 return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));
20908 }
20909 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
20910 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
20911 }
20912 static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {
20913 return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));
20914 }
20915 static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {
20916 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
20917 }
20918 static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {
20919 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
20920 }
20921 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
20922 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
20923 }
20924 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
20925 return (void *)((wxObject *) ((wxSizerItem *) x));
20926 }
20927 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
20928 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
20929 }
20930 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
20931 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
20932 }
20933 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
20934 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
20935 }
20936 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
20937 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
20938 }
20939 static void *_p_wxSizerTo_p_wxObject(void *x) {
20940 return (void *)((wxObject *) ((wxSizer *) x));
20941 }
20942 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
20943 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
20944 }
20945 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
20946 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
20947 }
20948 static void *_p_wxPyPanelTo_p_wxObject(void *x) {
20949 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));
20950 }
20951 static void *_p_wxEventTo_p_wxObject(void *x) {
20952 return (void *)((wxObject *) ((wxEvent *) x));
20953 }
20954 static void *_p_wxFontDataTo_p_wxObject(void *x) {
20955 return (void *)((wxObject *) ((wxFontData *) x));
20956 }
20957 static void *_p_wxPrintDataTo_p_wxObject(void *x) {
20958 return (void *)((wxObject *) ((wxPrintData *) x));
20959 }
20960 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
20961 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
20962 }
20963 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
20964 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
20965 }
20966 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
20967 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
20968 }
20969 static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {
20970 return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));
20971 }
20972 static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {
20973 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));
20974 }
20975 static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {
20976 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));
20977 }
20978 static void *_p_wxGridStringTableTo_p_wxObject(void *x) {
20979 return (void *)((wxObject *) (wxGridTableBase *) ((wxGridStringTable *) x));
20980 }
20981 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
20982 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
20983 }
20984 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
20985 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
20986 }
20987 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
20988 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
20989 }
20990 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
20991 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
20992 }
20993 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
20994 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
20995 }
20996 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
20997 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
20998 }
20999 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21000 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21001 }
21002 static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {
21003 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21004 }
21005 static void *_p_wxGridEventTo_p_wxObject(void *x) {
21006 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridEvent *) x));
21007 }
21008 static void *_p_wxGridEditorCreatedEventTo_p_wxObject(void *x) {
21009 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21010 }
21011 static void *_p_wxControlTo_p_wxObject(void *x) {
21012 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21013 }
21014 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21015 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21016 }
21017 static void *_p_wxSplitterEventTo_p_wxObject(void *x) {
21018 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));
21019 }
21020 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21021 return (void *)((wxObject *) ((wxFSFile *) x));
21022 }
21023 static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {
21024 return (void *)((wxObject *) ((wxFindReplaceData *) x));
21025 }
21026 static void *_p_wxGridTo_p_wxObject(void *x) {
21027 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21028 }
21029 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21030 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21031 }
21032 static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {
21033 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21034 }
21035 static void *_p_wxColourDataTo_p_wxObject(void *x) {
21036 return (void *)((wxObject *) ((wxColourData *) x));
21037 }
21038 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21039 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21040 }
21041 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21042 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21043 }
21044 static void *_p_wxPyWindowTo_p_wxObject(void *x) {
21045 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));
21046 }
21047 static void *_p_wxSplashScreenTo_p_wxObject(void *x) {
21048 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21049 }
21050 static void *_p_wxFileDialogTo_p_wxObject(void *x) {
21051 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21052 }
21053 static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {
21054 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21055 }
21056 static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {
21057 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21058 }
21059 static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {
21060 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21061 }
21062 static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {
21063 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21064 }
21065 static void *_p_wxMessageDialogTo_p_wxObject(void *x) {
21066 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21067 }
21068 static void *_p_wxProgressDialogTo_p_wxObject(void *x) {
21069 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21070 }
21071 static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {
21072 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21073 }
21074 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21075 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21076 }
21077 static void *_p_wxPrinterTo_p_wxObject(void *x) {
21078 return (void *)((wxObject *) ((wxPrinter *) x));
21079 }
21080 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21081 return (void *)((wxObject *) ((wxMenuItem *) x));
21082 }
21083 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21084 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21085 }
21086 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21087 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21088 }
21089 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21090 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21091 }
21092 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21093 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21094 }
21095 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21096 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21097 }
21098 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21099 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21100 }
21101 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21102 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21103 }
21104 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21105 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21106 }
21107 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21108 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21109 }
21110 static void *_p_wxGridSizeEventTo_p_wxObject(void *x) {
21111 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridSizeEvent *) x));
21112 }
21113 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21114 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21115 }
21116 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21117 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21118 }
21119 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21120 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21121 }
21122 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21123 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21124 }
21125 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21126 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21127 }
21128 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21129 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21130 }
21131 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21132 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21133 }
21134 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21135 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21136 }
21137 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21138 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21139 }
21140 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
21141 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
21142 }
21143 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21144 return (void *)((wxObject *) ((wxImageHandler *) x));
21145 }
21146 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21147 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21148 }
21149 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21150 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21151 }
21152 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21153 return (void *)((wxObject *) ((wxEvtHandler *) x));
21154 }
21155 static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {
21156 return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));
21157 }
21158 static void *_p_wxGridRangeSelectEventTo_p_wxObject(void *x) {
21159 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21160 }
21161 static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {
21162 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21163 }
21164 static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {
21165 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21166 }
21167 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21168 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21169 }
21170 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21171 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21172 }
21173 static void *_p_wxMiniFrameTo_p_wxObject(void *x) {
21174 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21175 }
21176 static void *_p_wxImageTo_p_wxObject(void *x) {
21177 return (void *)((wxObject *) ((wxImage *) x));
21178 }
21179 static void *_p_wxFrameTo_p_wxObject(void *x) {
21180 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21181 }
21182 static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {
21183 return (void *)((wxObject *) ((wxPyPrintout *) x));
21184 }
21185 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21186 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21187 }
21188 static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {
21189 return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));
21190 }
21191 static void *_p_wxStatusBarTo_p_wxObject(void *x) {
21192 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));
21193 }
21194 static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {
21195 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21196 }
21197 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21198 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21199 }
21200 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21201 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21202 }
21203 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21204 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21205 }
21206 static void *_p_wxWindowTo_p_wxObject(void *x) {
21207 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21208 }
21209 static void *_p_wxMenuTo_p_wxObject(void *x) {
21210 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21211 }
21212 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21213 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21214 }
21215 static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {
21216 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21217 }
21218 static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {
21219 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));
21220 }
21221 static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {
21222 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));
21223 }
21224 static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {
21225 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));
21226 }
21227 static void *_p_wxSashWindowTo_p_wxObject(void *x) {
21228 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));
21229 }
21230 static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {
21231 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21232 }
21233 static void *_p_wxPopupWindowTo_p_wxObject(void *x) {
21234 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));
21235 }
21236 static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {
21237 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21238 }
21239 static void *_p_wxTipWindowTo_p_wxObject(void *x) {
21240 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21241 }
21242 static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {
21243 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21244 }
21245 static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {
21246 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));
21247 }
21248 static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {
21249 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21250 }
21251 static void *_p_wxSashEventTo_p_wxObject(void *x) {
21252 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));
21253 }
21254 static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {
21255 return (void *)((wxObject *) ((wxPrintPreview *) x));
21256 }
21257 static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {
21258 return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));
21259 }
21260 static void *_p_wxPanelTo_p_wxObject(void *x) {
21261 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));
21262 }
21263 static void *_p_wxDialogTo_p_wxObject(void *x) {
21264 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21265 }
21266 static void *_p_wxColourDialogTo_p_wxObject(void *x) {
21267 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21268 }
21269 static void *_p_wxDirDialogTo_p_wxObject(void *x) {
21270 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21271 }
21272 static void *_p_wxFontDialogTo_p_wxObject(void *x) {
21273 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21274 }
21275 static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {
21276 return (void *)((wxObject *) ((wxPageSetupDialog *) x));
21277 }
21278 static void *_p_wxPrintDialogTo_p_wxObject(void *x) {
21279 return (void *)((wxObject *) ((wxPrintDialog *) x));
21280 }
21281 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21282 return (void *)((wxObject *) ((wxFileSystem *) x));
21283 }
21284 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21285 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21286 }
21287 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21288 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21289 }
21290 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21291 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21292 }
21293 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21294 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21295 }
21296 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21297 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21298 }
21299 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21300 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21301 }
21302 static void *_p_wxGridTableBaseTo_p_wxObject(void *x) {
21303 return (void *)((wxObject *) ((wxGridTableBase *) x));
21304 }
21305 static void *_p_wxPyGridTableBaseTo_p_wxObject(void *x) {
21306 return (void *)((wxObject *) (wxGridTableBase *) ((wxPyGridTableBase *) x));
21307 }
21308 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21309 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21310 }
21311 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21312 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21313 }
21314 static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {
21315 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21316 }
21317 static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {
21318 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21319 }
21320 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21321 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21322 }
21323 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21324 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21325 }
21326 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21327 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21328 }
21329 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21330 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21331 }
21332 static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {
21333 return (void *)((wxObject *) ((wxPageSetupDialogData *) x));
21334 }
21335 static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {
21336 return (void *)((wxObject *) ((wxPrintDialogData *) x));
21337 }
21338 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21339 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21340 }
21341 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21342 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21343 }
21344 static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {
21345 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));
21346 }
21347 static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {
21348 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));
21349 }
21350 static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {
21351 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));
21352 }
21353 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
21354 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
21355 }
21356 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
21357 return (void *)((wxEvtHandler *) ((wxValidator *) x));
21358 }
21359 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
21360 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
21361 }
21362 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
21363 return (void *)((wxEvtHandler *) ((wxMenu *) x));
21364 }
21365 static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {
21366 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));
21367 }
21368 static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {
21369 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));
21370 }
21371 static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {
21372 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));
21373 }
21374 static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {
21375 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));
21376 }
21377 static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {
21378 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));
21379 }
21380 static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {
21381 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));
21382 }
21383 static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {
21384 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxProgressDialog *) x));
21385 }
21386 static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {
21387 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));
21388 }
21389 static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {
21390 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));
21391 }
21392 static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {
21393 return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));
21394 }
21395 static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {
21396 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));
21397 }
21398 static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {
21399 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));
21400 }
21401 static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {
21402 return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));
21403 }
21404 static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {
21405 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));
21406 }
21407 static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {
21408 return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));
21409 }
21410 static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {
21411 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));
21412 }
21413 static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {
21414 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));
21415 }
21416 static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {
21417 return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));
21418 }
21419 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
21420 return (void *)((wxEvtHandler *) ((wxWindow *) x));
21421 }
21422 static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {
21423 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));
21424 }
21425 static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {
21426 return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));
21427 }
21428 static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {
21429 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));
21430 }
21431 static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {
21432 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));
21433 }
21434 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
21435 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
21436 }
21437 static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {
21438 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));
21439 }
21440 static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {
21441 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));
21442 }
21443 static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {
21444 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));
21445 }
21446 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
21447 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
21448 }
21449 static void *_p_wxGridTo_p_wxEvtHandler(void *x) {
21450 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxGrid *) x));
21451 }
21452 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
21453 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21454 }
21455 static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {
21456 return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));
21457 }
21458 static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {
21459 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));
21460 }
21461 static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {
21462 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));
21463 }
21464 static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {
21465 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));
21466 }
21467 static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {
21468 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));
21469 }
21470 static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {
21471 return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));
21472 }
21473 static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {
21474 return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));
21475 }
21476 static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {
21477 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));
21478 }
21479 static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {
21480 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));
21481 }
21482 static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {
21483 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));
21484 }
21485 static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {
21486 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));
21487 }
21488 static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {
21489 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));
21490 }
21491 static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {
21492 return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));
21493 }
21494 static void *_p_wxGridStringTableTo_p_wxGridTableBase(void *x) {
21495 return (void *)((wxGridTableBase *) ((wxGridStringTable *) x));
21496 }
21497 static void *_p_wxPyGridTableBaseTo_p_wxGridTableBase(void *x) {
21498 return (void *)((wxGridTableBase *) ((wxPyGridTableBase *) x));
21499 }
21500 static void *_p_wxPyGridCellEditorTo_p_wxGridCellEditor(void *x) {
21501 return (void *)((wxGridCellEditor *) ((wxPyGridCellEditor *) x));
21502 }
21503 static void *_p_wxGridCellTextEditorTo_p_wxGridCellEditor(void *x) {
21504 return (void *)((wxGridCellEditor *) ((wxGridCellTextEditor *) x));
21505 }
21506 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellEditor(void *x) {
21507 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21508 }
21509 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellEditor(void *x) {
21510 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21511 }
21512 static void *_p_wxGridCellBoolEditorTo_p_wxGridCellEditor(void *x) {
21513 return (void *)((wxGridCellEditor *) ((wxGridCellBoolEditor *) x));
21514 }
21515 static void *_p_wxGridCellChoiceEditorTo_p_wxGridCellEditor(void *x) {
21516 return (void *)((wxGridCellEditor *) ((wxGridCellChoiceEditor *) x));
21517 }
21518 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellEditor(void *x) {
21519 return (void *)((wxGridCellEditor *) (wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21520 }
21521 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellEditor(void *x) {
21522 return (void *)((wxGridCellEditor *) (wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21523 }
21524 static void *_p_wxGridCellNumberEditorTo_p_wxGridCellTextEditor(void *x) {
21525 return (void *)((wxGridCellTextEditor *) ((wxGridCellNumberEditor *) x));
21526 }
21527 static void *_p_wxGridCellFloatEditorTo_p_wxGridCellTextEditor(void *x) {
21528 return (void *)((wxGridCellTextEditor *) ((wxGridCellFloatEditor *) x));
21529 }
21530 static void *_p_wxGridCellAutoWrapStringEditorTo_p_wxGridCellTextEditor(void *x) {
21531 return (void *)((wxGridCellTextEditor *) ((wxGridCellAutoWrapStringEditor *) x));
21532 }
21533 static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {
21534 return (void *)((wxCommandEvent *) ((wxSashEvent *) x));
21535 }
21536 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
21537 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21538 }
21539 static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {
21540 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));
21541 }
21542 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
21543 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
21544 }
21545 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
21546 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
21547 }
21548 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
21549 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
21550 }
21551 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
21552 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
21553 }
21554 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
21555 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
21556 }
21557 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
21558 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
21559 }
21560 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
21561 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
21562 }
21563 static void *_p_wxGridSizeEventTo_p_wxCommandEvent(void *x) {
21564 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridSizeEvent *) x));
21565 }
21566 static void *_p_wxGridRangeSelectEventTo_p_wxCommandEvent(void *x) {
21567 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridRangeSelectEvent *) x));
21568 }
21569 static void *_p_wxGridEventTo_p_wxCommandEvent(void *x) {
21570 return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxGridEvent *) x));
21571 }
21572 static void *_p_wxGridEditorCreatedEventTo_p_wxCommandEvent(void *x) {
21573 return (void *)((wxCommandEvent *) ((wxGridEditorCreatedEvent *) x));
21574 }
21575 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
21576 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
21577 }
21578 static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {
21579 return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));
21580 }
21581 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
21582 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
21583 }
21584 static void *_p_wxPyGridCellAttrProviderTo_p_wxGridCellAttrProvider(void *x) {
21585 return (void *)((wxGridCellAttrProvider *) ((wxPyGridCellAttrProvider *) x));
21586 }
21587 static void *_p_wxGridCellEnumEditorTo_p_wxGridCellChoiceEditor(void *x) {
21588 return (void *)((wxGridCellChoiceEditor *) ((wxGridCellEnumEditor *) x));
21589 }
21590 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21591 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};
21592 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
21593 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
21594 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
21595 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
21596 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
21597 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
21598 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
21599 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
21600 static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};
21601 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
21602 static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};
21603 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
21604 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
21605 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
21606 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
21607 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
21608 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
21609 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
21610 static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};
21611 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
21612 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
21613 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
21614 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
21615 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
21616 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
21617 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
21618 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
21619 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
21620 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
21621 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
21622 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
21623 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
21624 static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};
21625 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
21626 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
21627 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
21628 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
21629 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
21630 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
21631 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
21632 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
21633 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
21634 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
21635 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
21636 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
21637 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
21638 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
21639 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
21640 static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};
21641 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
21642 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
21643 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
21644 static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};
21645 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
21646 static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};
21647 static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};
21648 static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};
21649 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
21650 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
21651 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
21652 static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};
21653 static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};
21654 static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};
21655 static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};
21656 static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};
21657 static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};
21658 static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};
21659 static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};
21660 static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};
21661 static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};
21662 static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};
21663 static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};
21664 static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};
21665 static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};
21666 static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};
21667 static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};
21668 static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};
21669 static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};
21670 static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};
21671 static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};
21672 static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};
21673 static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};
21674 static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};
21675 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
21676 static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};
21677 static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};
21678 static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};
21679 static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};
21680 static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};
21681 static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};
21682 static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};
21683 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};
21684 static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};
21685 static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};
21686 static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};
21687 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};
21688 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
21689 static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};
21690 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
21691 static swig_type_info _swigt__p_wxGrid = {"_p_wxGrid", "wxGrid *", 0, 0, (void*)0, 0};
21692 static swig_type_info _swigt__p_wxGridCellAttr = {"_p_wxGridCellAttr", "wxGridCellAttr *", 0, 0, (void*)0, 0};
21693 static swig_type_info _swigt__p_wxGridCellAttrProvider = {"_p_wxGridCellAttrProvider", "wxGridCellAttrProvider *", 0, 0, (void*)0, 0};
21694 static swig_type_info _swigt__p_wxGridCellAutoWrapStringEditor = {"_p_wxGridCellAutoWrapStringEditor", "wxGridCellAutoWrapStringEditor *", 0, 0, (void*)0, 0};
21695 static swig_type_info _swigt__p_wxGridCellAutoWrapStringRenderer = {"_p_wxGridCellAutoWrapStringRenderer", "wxGridCellAutoWrapStringRenderer *", 0, 0, (void*)0, 0};
21696 static swig_type_info _swigt__p_wxGridCellBoolEditor = {"_p_wxGridCellBoolEditor", "wxGridCellBoolEditor *", 0, 0, (void*)0, 0};
21697 static swig_type_info _swigt__p_wxGridCellBoolRenderer = {"_p_wxGridCellBoolRenderer", "wxGridCellBoolRenderer *", 0, 0, (void*)0, 0};
21698 static swig_type_info _swigt__p_wxGridCellChoiceEditor = {"_p_wxGridCellChoiceEditor", "wxGridCellChoiceEditor *", 0, 0, (void*)0, 0};
21699 static swig_type_info _swigt__p_wxGridCellCoords = {"_p_wxGridCellCoords", "wxGridCellCoords *", 0, 0, (void*)0, 0};
21700 static swig_type_info _swigt__p_wxGridCellDateTimeRenderer = {"_p_wxGridCellDateTimeRenderer", "wxGridCellDateTimeRenderer *", 0, 0, (void*)0, 0};
21701 static swig_type_info _swigt__p_wxGridCellEditor = {"_p_wxGridCellEditor", "wxGridCellEditor *", 0, 0, (void*)0, 0};
21702 static swig_type_info _swigt__p_wxGridCellEnumEditor = {"_p_wxGridCellEnumEditor", "wxGridCellEnumEditor *", 0, 0, (void*)0, 0};
21703 static swig_type_info _swigt__p_wxGridCellEnumRenderer = {"_p_wxGridCellEnumRenderer", "wxGridCellEnumRenderer *", 0, 0, (void*)0, 0};
21704 static swig_type_info _swigt__p_wxGridCellFloatEditor = {"_p_wxGridCellFloatEditor", "wxGridCellFloatEditor *", 0, 0, (void*)0, 0};
21705 static swig_type_info _swigt__p_wxGridCellFloatRenderer = {"_p_wxGridCellFloatRenderer", "wxGridCellFloatRenderer *", 0, 0, (void*)0, 0};
21706 static swig_type_info _swigt__p_wxGridCellNumberEditor = {"_p_wxGridCellNumberEditor", "wxGridCellNumberEditor *", 0, 0, (void*)0, 0};
21707 static swig_type_info _swigt__p_wxGridCellNumberRenderer = {"_p_wxGridCellNumberRenderer", "wxGridCellNumberRenderer *", 0, 0, (void*)0, 0};
21708 static swig_type_info _swigt__p_wxGridCellRenderer = {"_p_wxGridCellRenderer", "wxGridCellRenderer *", 0, 0, (void*)0, 0};
21709 static swig_type_info _swigt__p_wxGridCellStringRenderer = {"_p_wxGridCellStringRenderer", "wxGridCellStringRenderer *", 0, 0, (void*)0, 0};
21710 static swig_type_info _swigt__p_wxGridCellTextEditor = {"_p_wxGridCellTextEditor", "wxGridCellTextEditor *", 0, 0, (void*)0, 0};
21711 static swig_type_info _swigt__p_wxGridCellWorker = {"_p_wxGridCellWorker", "wxGridCellWorker *", 0, 0, (void*)0, 0};
21712 static swig_type_info _swigt__p_wxGridEditorCreatedEvent = {"_p_wxGridEditorCreatedEvent", "wxGridEditorCreatedEvent *", 0, 0, (void*)0, 0};
21713 static swig_type_info _swigt__p_wxGridEvent = {"_p_wxGridEvent", "wxGridEvent *", 0, 0, (void*)0, 0};
21714 static swig_type_info _swigt__p_wxGridRangeSelectEvent = {"_p_wxGridRangeSelectEvent", "wxGridRangeSelectEvent *", 0, 0, (void*)0, 0};
21715 static swig_type_info _swigt__p_wxGridSizeEvent = {"_p_wxGridSizeEvent", "wxGridSizeEvent *", 0, 0, (void*)0, 0};
21716 static swig_type_info _swigt__p_wxGridStringTable = {"_p_wxGridStringTable", "wxGridStringTable *", 0, 0, (void*)0, 0};
21717 static swig_type_info _swigt__p_wxGridTableBase = {"_p_wxGridTableBase", "wxGridTableBase *", 0, 0, (void*)0, 0};
21718 static swig_type_info _swigt__p_wxGridTableMessage = {"_p_wxGridTableMessage", "wxGridTableMessage *", 0, 0, (void*)0, 0};
21719 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
21720 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
21721 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
21722 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
21723 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
21724 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
21725 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
21726 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
21727 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
21728 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
21729 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
21730 static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};
21731 static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", 0, 0, 0, 0, 0};
21732 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
21733 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
21734 static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};
21735 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
21736 static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};
21737 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
21738 static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};
21739 static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};
21740 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
21741 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
21742 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
21743 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
21744 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
21745 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
21746 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
21747 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
21748 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
21749 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
21750 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
21751 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
21752 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
21753 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
21754 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
21755 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
21756 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
21757 static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", 0, 0, 0, 0, 0};
21758 static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};
21759 static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};
21760 static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};
21761 static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};
21762 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
21763 static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", 0, 0, 0, 0, 0};
21764 static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};
21765 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
21766 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
21767 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
21768 static swig_type_info _swigt__p_wxPyGridCellAttrProvider = {"_p_wxPyGridCellAttrProvider", "wxPyGridCellAttrProvider *", 0, 0, (void*)0, 0};
21769 static swig_type_info _swigt__p_wxPyGridCellEditor = {"_p_wxPyGridCellEditor", "wxPyGridCellEditor *", 0, 0, (void*)0, 0};
21770 static swig_type_info _swigt__p_wxPyGridCellRenderer = {"_p_wxPyGridCellRenderer", "wxPyGridCellRenderer *", 0, 0, (void*)0, 0};
21771 static swig_type_info _swigt__p_wxPyGridTableBase = {"_p_wxPyGridTableBase", "wxPyGridTableBase *", 0, 0, (void*)0, 0};
21772 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
21773 static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", "wxScrolledWindow *", 0, 0, (void*)0, 0};
21774 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
21775 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
21776 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
21777
21778 static swig_type_info *swig_type_initial[] = {
21779 &_swigt__p_char,
21780 &_swigt__p_form_ops_t,
21781 &_swigt__p_int,
21782 &_swigt__p_long,
21783 &_swigt__p_unsigned_char,
21784 &_swigt__p_unsigned_int,
21785 &_swigt__p_unsigned_long,
21786 &_swigt__p_wxANIHandler,
21787 &_swigt__p_wxAcceleratorTable,
21788 &_swigt__p_wxActivateEvent,
21789 &_swigt__p_wxArrayString,
21790 &_swigt__p_wxBMPHandler,
21791 &_swigt__p_wxBoxSizer,
21792 &_swigt__p_wxCURHandler,
21793 &_swigt__p_wxCalculateLayoutEvent,
21794 &_swigt__p_wxChildFocusEvent,
21795 &_swigt__p_wxClipboardTextEvent,
21796 &_swigt__p_wxCloseEvent,
21797 &_swigt__p_wxColour,
21798 &_swigt__p_wxColourData,
21799 &_swigt__p_wxColourDialog,
21800 &_swigt__p_wxCommandEvent,
21801 &_swigt__p_wxContextMenuEvent,
21802 &_swigt__p_wxControl,
21803 &_swigt__p_wxControlWithItems,
21804 &_swigt__p_wxDC,
21805 &_swigt__p_wxDateEvent,
21806 &_swigt__p_wxDialog,
21807 &_swigt__p_wxDirDialog,
21808 &_swigt__p_wxDisplayChangedEvent,
21809 &_swigt__p_wxDropFilesEvent,
21810 &_swigt__p_wxDuplexMode,
21811 &_swigt__p_wxEraseEvent,
21812 &_swigt__p_wxEvent,
21813 &_swigt__p_wxEvtHandler,
21814 &_swigt__p_wxFSFile,
21815 &_swigt__p_wxFileDialog,
21816 &_swigt__p_wxFileSystem,
21817 &_swigt__p_wxFindDialogEvent,
21818 &_swigt__p_wxFindReplaceData,
21819 &_swigt__p_wxFindReplaceDialog,
21820 &_swigt__p_wxFlexGridSizer,
21821 &_swigt__p_wxFocusEvent,
21822 &_swigt__p_wxFont,
21823 &_swigt__p_wxFontData,
21824 &_swigt__p_wxFontDialog,
21825 &_swigt__p_wxFrame,
21826 &_swigt__p_wxGBSizerItem,
21827 &_swigt__p_wxGIFHandler,
21828 &_swigt__p_wxGrid,
21829 &_swigt__p_wxGridBagSizer,
21830 &_swigt__p_wxGridCellAttr,
21831 &_swigt__p_wxGridCellAttrProvider,
21832 &_swigt__p_wxGridCellAutoWrapStringEditor,
21833 &_swigt__p_wxGridCellAutoWrapStringRenderer,
21834 &_swigt__p_wxGridCellBoolEditor,
21835 &_swigt__p_wxGridCellBoolRenderer,
21836 &_swigt__p_wxGridCellChoiceEditor,
21837 &_swigt__p_wxGridCellCoords,
21838 &_swigt__p_wxGridCellDateTimeRenderer,
21839 &_swigt__p_wxGridCellEditor,
21840 &_swigt__p_wxGridCellEnumEditor,
21841 &_swigt__p_wxGridCellEnumRenderer,
21842 &_swigt__p_wxGridCellFloatEditor,
21843 &_swigt__p_wxGridCellFloatRenderer,
21844 &_swigt__p_wxGridCellNumberEditor,
21845 &_swigt__p_wxGridCellNumberRenderer,
21846 &_swigt__p_wxGridCellRenderer,
21847 &_swigt__p_wxGridCellStringRenderer,
21848 &_swigt__p_wxGridCellTextEditor,
21849 &_swigt__p_wxGridCellWorker,
21850 &_swigt__p_wxGridEditorCreatedEvent,
21851 &_swigt__p_wxGridEvent,
21852 &_swigt__p_wxGridRangeSelectEvent,
21853 &_swigt__p_wxGridSizeEvent,
21854 &_swigt__p_wxGridSizer,
21855 &_swigt__p_wxGridStringTable,
21856 &_swigt__p_wxGridTableBase,
21857 &_swigt__p_wxGridTableMessage,
21858 &_swigt__p_wxICOHandler,
21859 &_swigt__p_wxIconizeEvent,
21860 &_swigt__p_wxIdleEvent,
21861 &_swigt__p_wxImage,
21862 &_swigt__p_wxImageHandler,
21863 &_swigt__p_wxIndividualLayoutConstraint,
21864 &_swigt__p_wxInitDialogEvent,
21865 &_swigt__p_wxJPEGHandler,
21866 &_swigt__p_wxKeyEvent,
21867 &_swigt__p_wxLayoutAlgorithm,
21868 &_swigt__p_wxLayoutConstraints,
21869 &_swigt__p_wxMDIChildFrame,
21870 &_swigt__p_wxMDIClientWindow,
21871 &_swigt__p_wxMDIParentFrame,
21872 &_swigt__p_wxMaximizeEvent,
21873 &_swigt__p_wxMenu,
21874 &_swigt__p_wxMenuBar,
21875 &_swigt__p_wxMenuEvent,
21876 &_swigt__p_wxMenuItem,
21877 &_swigt__p_wxMessageDialog,
21878 &_swigt__p_wxMiniFrame,
21879 &_swigt__p_wxMouseCaptureChangedEvent,
21880 &_swigt__p_wxMouseEvent,
21881 &_swigt__p_wxMoveEvent,
21882 &_swigt__p_wxMultiChoiceDialog,
21883 &_swigt__p_wxNavigationKeyEvent,
21884 &_swigt__p_wxNcPaintEvent,
21885 &_swigt__p_wxNotifyEvent,
21886 &_swigt__p_wxObject,
21887 &_swigt__p_wxPCXHandler,
21888 &_swigt__p_wxPNGHandler,
21889 &_swigt__p_wxPNMHandler,
21890 &_swigt__p_wxPageSetupDialog,
21891 &_swigt__p_wxPageSetupDialogData,
21892 &_swigt__p_wxPaintEvent,
21893 &_swigt__p_wxPaletteChangedEvent,
21894 &_swigt__p_wxPanel,
21895 &_swigt__p_wxPaperSize,
21896 &_swigt__p_wxPasswordEntryDialog,
21897 &_swigt__p_wxPoint,
21898 &_swigt__p_wxPopupWindow,
21899 &_swigt__p_wxPreviewCanvas,
21900 &_swigt__p_wxPreviewControlBar,
21901 &_swigt__p_wxPreviewFrame,
21902 &_swigt__p_wxPrintData,
21903 &_swigt__p_wxPrintDialog,
21904 &_swigt__p_wxPrintDialogData,
21905 &_swigt__p_wxPrintPreview,
21906 &_swigt__p_wxPrinter,
21907 &_swigt__p_wxProgressDialog,
21908 &_swigt__p_wxPyApp,
21909 &_swigt__p_wxPyCommandEvent,
21910 &_swigt__p_wxPyEvent,
21911 &_swigt__p_wxPyGridCellAttrProvider,
21912 &_swigt__p_wxPyGridCellEditor,
21913 &_swigt__p_wxPyGridCellRenderer,
21914 &_swigt__p_wxPyGridTableBase,
21915 &_swigt__p_wxPyHtmlListBox,
21916 &_swigt__p_wxPyImageHandler,
21917 &_swigt__p_wxPyPanel,
21918 &_swigt__p_wxPyPopupTransientWindow,
21919 &_swigt__p_wxPyPreviewControlBar,
21920 &_swigt__p_wxPyPreviewFrame,
21921 &_swigt__p_wxPyPrintPreview,
21922 &_swigt__p_wxPyPrintout,
21923 &_swigt__p_wxPyScrolledWindow,
21924 &_swigt__p_wxPySizer,
21925 &_swigt__p_wxPyTaskBarIcon,
21926 &_swigt__p_wxPyVListBox,
21927 &_swigt__p_wxPyVScrolledWindow,
21928 &_swigt__p_wxPyValidator,
21929 &_swigt__p_wxPyWindow,
21930 &_swigt__p_wxQueryLayoutInfoEvent,
21931 &_swigt__p_wxQueryNewPaletteEvent,
21932 &_swigt__p_wxRect,
21933 &_swigt__p_wxSashEvent,
21934 &_swigt__p_wxSashLayoutWindow,
21935 &_swigt__p_wxSashWindow,
21936 &_swigt__p_wxScrollEvent,
21937 &_swigt__p_wxScrollWinEvent,
21938 &_swigt__p_wxScrolledWindow,
21939 &_swigt__p_wxSetCursorEvent,
21940 &_swigt__p_wxShowEvent,
21941 &_swigt__p_wxSingleChoiceDialog,
21942 &_swigt__p_wxSizeEvent,
21943 &_swigt__p_wxSizer,
21944 &_swigt__p_wxSizerItem,
21945 &_swigt__p_wxSplashScreen,
21946 &_swigt__p_wxSplashScreenWindow,
21947 &_swigt__p_wxSplitterEvent,
21948 &_swigt__p_wxSplitterWindow,
21949 &_swigt__p_wxStaticBoxSizer,
21950 &_swigt__p_wxStatusBar,
21951 &_swigt__p_wxStdDialogButtonSizer,
21952 &_swigt__p_wxString,
21953 &_swigt__p_wxSysColourChangedEvent,
21954 &_swigt__p_wxTIFFHandler,
21955 &_swigt__p_wxTaskBarIconEvent,
21956 &_swigt__p_wxTextEntryDialog,
21957 &_swigt__p_wxTipWindow,
21958 &_swigt__p_wxTopLevelWindow,
21959 &_swigt__p_wxUpdateUIEvent,
21960 &_swigt__p_wxValidator,
21961 &_swigt__p_wxVisualAttributes,
21962 &_swigt__p_wxWindow,
21963 &_swigt__p_wxWindowCreateEvent,
21964 &_swigt__p_wxWindowDestroyEvent,
21965 &_swigt__p_wxXPMHandler,
21966 };
21967
21968 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
21969 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
21970 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
21971 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
21972 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
21973 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
21974 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
21975 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
21976 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
21977 static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};
21978 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
21979 static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};
21980 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
21981 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
21982 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
21983 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
21984 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
21985 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
21986 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
21987 static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
21988 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
21989 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}};
21990 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
21991 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}};
21992 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
21993 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
21994 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
21995 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
21996 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
21997 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
21998 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
21999 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
22000 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
22001 static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};
22002 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
22003 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
22004 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22005 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22006 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
22007 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22008 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
22009 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22010 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
22011 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22012 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22013 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22014 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
22015 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
22016 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
22017 static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};
22018 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
22019 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22020 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
22021 static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};
22022 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
22023 static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};
22024 static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};
22025 static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};
22026 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
22027 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
22028 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
22029 static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};
22030 static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};
22031 static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
22032 static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
22033 static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22034 static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};
22035 static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22036 static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};
22037 static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};
22038 static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};
22039 static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};
22040 static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};
22041 static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};
22042 static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};
22043 static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};
22044 static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};
22045 static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22046 static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};
22047 static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};
22048 static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};
22049 static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22050 static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};
22051 static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};
22052 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
22053 static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};
22054 static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};
22055 static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};
22056 static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};
22057 static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22058 static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};
22059 static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};
22060 static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
22061 static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};
22062 static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};
22063 static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};
22064 static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
22065 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
22066 static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};
22067 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
22068 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
22069 static swig_cast_info _swigc__p_wxGrid[] = { {&_swigt__p_wxGrid, 0, 0, 0},{0, 0, 0, 0}};
22070 static swig_cast_info _swigc__p_wxGridCellAttr[] = { {&_swigt__p_wxGridCellAttr, 0, 0, 0},{0, 0, 0, 0}};
22071 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}};
22072 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringEditor[] = { {&_swigt__p_wxGridCellAutoWrapStringEditor, 0, 0, 0},{0, 0, 0, 0}};
22073 static swig_cast_info _swigc__p_wxGridCellAutoWrapStringRenderer[] = { {&_swigt__p_wxGridCellAutoWrapStringRenderer, 0, 0, 0},{0, 0, 0, 0}};
22074 static swig_cast_info _swigc__p_wxGridCellBoolEditor[] = { {&_swigt__p_wxGridCellBoolEditor, 0, 0, 0},{0, 0, 0, 0}};
22075 static swig_cast_info _swigc__p_wxGridCellBoolRenderer[] = { {&_swigt__p_wxGridCellBoolRenderer, 0, 0, 0},{0, 0, 0, 0}};
22076 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}};
22077 static swig_cast_info _swigc__p_wxGridCellCoords[] = { {&_swigt__p_wxGridCellCoords, 0, 0, 0},{0, 0, 0, 0}};
22078 static swig_cast_info _swigc__p_wxGridCellDateTimeRenderer[] = { {&_swigt__p_wxGridCellDateTimeRenderer, 0, 0, 0},{0, 0, 0, 0}};
22079 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}};
22080 static swig_cast_info _swigc__p_wxGridCellEnumEditor[] = { {&_swigt__p_wxGridCellEnumEditor, 0, 0, 0},{0, 0, 0, 0}};
22081 static swig_cast_info _swigc__p_wxGridCellEnumRenderer[] = { {&_swigt__p_wxGridCellEnumRenderer, 0, 0, 0},{0, 0, 0, 0}};
22082 static swig_cast_info _swigc__p_wxGridCellFloatEditor[] = { {&_swigt__p_wxGridCellFloatEditor, 0, 0, 0},{0, 0, 0, 0}};
22083 static swig_cast_info _swigc__p_wxGridCellFloatRenderer[] = { {&_swigt__p_wxGridCellFloatRenderer, 0, 0, 0},{0, 0, 0, 0}};
22084 static swig_cast_info _swigc__p_wxGridCellNumberEditor[] = { {&_swigt__p_wxGridCellNumberEditor, 0, 0, 0},{0, 0, 0, 0}};
22085 static swig_cast_info _swigc__p_wxGridCellNumberRenderer[] = { {&_swigt__p_wxGridCellNumberRenderer, 0, 0, 0},{0, 0, 0, 0}};
22086 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}};
22087 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}};
22088 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}};
22089 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}};
22090 static swig_cast_info _swigc__p_wxGridEditorCreatedEvent[] = { {&_swigt__p_wxGridEditorCreatedEvent, 0, 0, 0},{0, 0, 0, 0}};
22091 static swig_cast_info _swigc__p_wxGridEvent[] = { {&_swigt__p_wxGridEvent, 0, 0, 0},{0, 0, 0, 0}};
22092 static swig_cast_info _swigc__p_wxGridRangeSelectEvent[] = { {&_swigt__p_wxGridRangeSelectEvent, 0, 0, 0},{0, 0, 0, 0}};
22093 static swig_cast_info _swigc__p_wxGridSizeEvent[] = { {&_swigt__p_wxGridSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
22094 static swig_cast_info _swigc__p_wxGridStringTable[] = { {&_swigt__p_wxGridStringTable, 0, 0, 0},{0, 0, 0, 0}};
22095 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}};
22096 static swig_cast_info _swigc__p_wxGridTableMessage[] = { {&_swigt__p_wxGridTableMessage, 0, 0, 0},{0, 0, 0, 0}};
22097 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
22098 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}};
22099 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
22100 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22101 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
22102 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
22103 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22104 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
22105 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
22106 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
22107 static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};
22108 static swig_cast_info _swigc__p_wxPrintData[] = {{&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};
22109 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22110 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
22111 static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
22112 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
22113 static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};
22114 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
22115 static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};
22116 static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};
22117 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
22118 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
22119 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
22120 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
22121 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
22122 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
22123 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
22124 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
22125 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
22126 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
22127 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22128 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
22129 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
22130 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
22131 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
22132 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
22133 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
22134 static swig_cast_info _swigc__p_wxPyPrintout[] = {{&_swigt__p_wxPyPrintout, 0, 0, 0},{0, 0, 0, 0}};
22135 static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22136 static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};
22137 static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};
22138 static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
22139 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
22140 static swig_cast_info _swigc__p_wxPageSetupDialogData[] = {{&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};
22141 static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};
22142 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridStringTable, _p_wxGridStringTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEditorCreatedEvent, _p_wxGridEditorCreatedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridEvent, _p_wxGridEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizeEvent, _p_wxGridSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridRangeSelectEvent, _p_wxGridRangeSelectEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridTableBase, _p_wxGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyGridTableBase, _p_wxPyGridTableBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
22143 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxPanel, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxPanel, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxPanel, 0, 0},{0, 0, 0, 0}};
22144 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
22145 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
22146 static swig_cast_info _swigc__p_wxPyGridCellAttrProvider[] = { {&_swigt__p_wxPyGridCellAttrProvider, 0, 0, 0},{0, 0, 0, 0}};
22147 static swig_cast_info _swigc__p_wxPyGridCellEditor[] = { {&_swigt__p_wxPyGridCellEditor, 0, 0, 0},{0, 0, 0, 0}};
22148 static swig_cast_info _swigc__p_wxPyGridCellRenderer[] = { {&_swigt__p_wxPyGridCellRenderer, 0, 0, 0},{0, 0, 0, 0}};
22149 static swig_cast_info _swigc__p_wxPyGridTableBase[] = { {&_swigt__p_wxPyGridTableBase, 0, 0, 0},{0, 0, 0, 0}};
22150 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
22151 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}};
22152 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
22153 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
22154 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxGrid, _p_wxGridTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
22155
22156 static swig_cast_info *swig_cast_initial[] = {
22157 _swigc__p_char,
22158 _swigc__p_form_ops_t,
22159 _swigc__p_int,
22160 _swigc__p_long,
22161 _swigc__p_unsigned_char,
22162 _swigc__p_unsigned_int,
22163 _swigc__p_unsigned_long,
22164 _swigc__p_wxANIHandler,
22165 _swigc__p_wxAcceleratorTable,
22166 _swigc__p_wxActivateEvent,
22167 _swigc__p_wxArrayString,
22168 _swigc__p_wxBMPHandler,
22169 _swigc__p_wxBoxSizer,
22170 _swigc__p_wxCURHandler,
22171 _swigc__p_wxCalculateLayoutEvent,
22172 _swigc__p_wxChildFocusEvent,
22173 _swigc__p_wxClipboardTextEvent,
22174 _swigc__p_wxCloseEvent,
22175 _swigc__p_wxColour,
22176 _swigc__p_wxColourData,
22177 _swigc__p_wxColourDialog,
22178 _swigc__p_wxCommandEvent,
22179 _swigc__p_wxContextMenuEvent,
22180 _swigc__p_wxControl,
22181 _swigc__p_wxControlWithItems,
22182 _swigc__p_wxDC,
22183 _swigc__p_wxDateEvent,
22184 _swigc__p_wxDialog,
22185 _swigc__p_wxDirDialog,
22186 _swigc__p_wxDisplayChangedEvent,
22187 _swigc__p_wxDropFilesEvent,
22188 _swigc__p_wxDuplexMode,
22189 _swigc__p_wxEraseEvent,
22190 _swigc__p_wxEvent,
22191 _swigc__p_wxEvtHandler,
22192 _swigc__p_wxFSFile,
22193 _swigc__p_wxFileDialog,
22194 _swigc__p_wxFileSystem,
22195 _swigc__p_wxFindDialogEvent,
22196 _swigc__p_wxFindReplaceData,
22197 _swigc__p_wxFindReplaceDialog,
22198 _swigc__p_wxFlexGridSizer,
22199 _swigc__p_wxFocusEvent,
22200 _swigc__p_wxFont,
22201 _swigc__p_wxFontData,
22202 _swigc__p_wxFontDialog,
22203 _swigc__p_wxFrame,
22204 _swigc__p_wxGBSizerItem,
22205 _swigc__p_wxGIFHandler,
22206 _swigc__p_wxGrid,
22207 _swigc__p_wxGridBagSizer,
22208 _swigc__p_wxGridCellAttr,
22209 _swigc__p_wxGridCellAttrProvider,
22210 _swigc__p_wxGridCellAutoWrapStringEditor,
22211 _swigc__p_wxGridCellAutoWrapStringRenderer,
22212 _swigc__p_wxGridCellBoolEditor,
22213 _swigc__p_wxGridCellBoolRenderer,
22214 _swigc__p_wxGridCellChoiceEditor,
22215 _swigc__p_wxGridCellCoords,
22216 _swigc__p_wxGridCellDateTimeRenderer,
22217 _swigc__p_wxGridCellEditor,
22218 _swigc__p_wxGridCellEnumEditor,
22219 _swigc__p_wxGridCellEnumRenderer,
22220 _swigc__p_wxGridCellFloatEditor,
22221 _swigc__p_wxGridCellFloatRenderer,
22222 _swigc__p_wxGridCellNumberEditor,
22223 _swigc__p_wxGridCellNumberRenderer,
22224 _swigc__p_wxGridCellRenderer,
22225 _swigc__p_wxGridCellStringRenderer,
22226 _swigc__p_wxGridCellTextEditor,
22227 _swigc__p_wxGridCellWorker,
22228 _swigc__p_wxGridEditorCreatedEvent,
22229 _swigc__p_wxGridEvent,
22230 _swigc__p_wxGridRangeSelectEvent,
22231 _swigc__p_wxGridSizeEvent,
22232 _swigc__p_wxGridSizer,
22233 _swigc__p_wxGridStringTable,
22234 _swigc__p_wxGridTableBase,
22235 _swigc__p_wxGridTableMessage,
22236 _swigc__p_wxICOHandler,
22237 _swigc__p_wxIconizeEvent,
22238 _swigc__p_wxIdleEvent,
22239 _swigc__p_wxImage,
22240 _swigc__p_wxImageHandler,
22241 _swigc__p_wxIndividualLayoutConstraint,
22242 _swigc__p_wxInitDialogEvent,
22243 _swigc__p_wxJPEGHandler,
22244 _swigc__p_wxKeyEvent,
22245 _swigc__p_wxLayoutAlgorithm,
22246 _swigc__p_wxLayoutConstraints,
22247 _swigc__p_wxMDIChildFrame,
22248 _swigc__p_wxMDIClientWindow,
22249 _swigc__p_wxMDIParentFrame,
22250 _swigc__p_wxMaximizeEvent,
22251 _swigc__p_wxMenu,
22252 _swigc__p_wxMenuBar,
22253 _swigc__p_wxMenuEvent,
22254 _swigc__p_wxMenuItem,
22255 _swigc__p_wxMessageDialog,
22256 _swigc__p_wxMiniFrame,
22257 _swigc__p_wxMouseCaptureChangedEvent,
22258 _swigc__p_wxMouseEvent,
22259 _swigc__p_wxMoveEvent,
22260 _swigc__p_wxMultiChoiceDialog,
22261 _swigc__p_wxNavigationKeyEvent,
22262 _swigc__p_wxNcPaintEvent,
22263 _swigc__p_wxNotifyEvent,
22264 _swigc__p_wxObject,
22265 _swigc__p_wxPCXHandler,
22266 _swigc__p_wxPNGHandler,
22267 _swigc__p_wxPNMHandler,
22268 _swigc__p_wxPageSetupDialog,
22269 _swigc__p_wxPageSetupDialogData,
22270 _swigc__p_wxPaintEvent,
22271 _swigc__p_wxPaletteChangedEvent,
22272 _swigc__p_wxPanel,
22273 _swigc__p_wxPaperSize,
22274 _swigc__p_wxPasswordEntryDialog,
22275 _swigc__p_wxPoint,
22276 _swigc__p_wxPopupWindow,
22277 _swigc__p_wxPreviewCanvas,
22278 _swigc__p_wxPreviewControlBar,
22279 _swigc__p_wxPreviewFrame,
22280 _swigc__p_wxPrintData,
22281 _swigc__p_wxPrintDialog,
22282 _swigc__p_wxPrintDialogData,
22283 _swigc__p_wxPrintPreview,
22284 _swigc__p_wxPrinter,
22285 _swigc__p_wxProgressDialog,
22286 _swigc__p_wxPyApp,
22287 _swigc__p_wxPyCommandEvent,
22288 _swigc__p_wxPyEvent,
22289 _swigc__p_wxPyGridCellAttrProvider,
22290 _swigc__p_wxPyGridCellEditor,
22291 _swigc__p_wxPyGridCellRenderer,
22292 _swigc__p_wxPyGridTableBase,
22293 _swigc__p_wxPyHtmlListBox,
22294 _swigc__p_wxPyImageHandler,
22295 _swigc__p_wxPyPanel,
22296 _swigc__p_wxPyPopupTransientWindow,
22297 _swigc__p_wxPyPreviewControlBar,
22298 _swigc__p_wxPyPreviewFrame,
22299 _swigc__p_wxPyPrintPreview,
22300 _swigc__p_wxPyPrintout,
22301 _swigc__p_wxPyScrolledWindow,
22302 _swigc__p_wxPySizer,
22303 _swigc__p_wxPyTaskBarIcon,
22304 _swigc__p_wxPyVListBox,
22305 _swigc__p_wxPyVScrolledWindow,
22306 _swigc__p_wxPyValidator,
22307 _swigc__p_wxPyWindow,
22308 _swigc__p_wxQueryLayoutInfoEvent,
22309 _swigc__p_wxQueryNewPaletteEvent,
22310 _swigc__p_wxRect,
22311 _swigc__p_wxSashEvent,
22312 _swigc__p_wxSashLayoutWindow,
22313 _swigc__p_wxSashWindow,
22314 _swigc__p_wxScrollEvent,
22315 _swigc__p_wxScrollWinEvent,
22316 _swigc__p_wxScrolledWindow,
22317 _swigc__p_wxSetCursorEvent,
22318 _swigc__p_wxShowEvent,
22319 _swigc__p_wxSingleChoiceDialog,
22320 _swigc__p_wxSizeEvent,
22321 _swigc__p_wxSizer,
22322 _swigc__p_wxSizerItem,
22323 _swigc__p_wxSplashScreen,
22324 _swigc__p_wxSplashScreenWindow,
22325 _swigc__p_wxSplitterEvent,
22326 _swigc__p_wxSplitterWindow,
22327 _swigc__p_wxStaticBoxSizer,
22328 _swigc__p_wxStatusBar,
22329 _swigc__p_wxStdDialogButtonSizer,
22330 _swigc__p_wxString,
22331 _swigc__p_wxSysColourChangedEvent,
22332 _swigc__p_wxTIFFHandler,
22333 _swigc__p_wxTaskBarIconEvent,
22334 _swigc__p_wxTextEntryDialog,
22335 _swigc__p_wxTipWindow,
22336 _swigc__p_wxTopLevelWindow,
22337 _swigc__p_wxUpdateUIEvent,
22338 _swigc__p_wxValidator,
22339 _swigc__p_wxVisualAttributes,
22340 _swigc__p_wxWindow,
22341 _swigc__p_wxWindowCreateEvent,
22342 _swigc__p_wxWindowDestroyEvent,
22343 _swigc__p_wxXPMHandler,
22344 };
22345
22346
22347 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22348
22349 static swig_const_info swig_const_table[] = {
22350 {0, 0, 0, 0.0, 0, 0}};
22351
22352 #ifdef __cplusplus
22353 }
22354 #endif
22355 /* -----------------------------------------------------------------------------
22356 * Type initialization:
22357 * This problem is tough by the requirement that no dynamic
22358 * memory is used. Also, since swig_type_info structures store pointers to
22359 * swig_cast_info structures and swig_cast_info structures store pointers back
22360 * to swig_type_info structures, we need some lookup code at initialization.
22361 * The idea is that swig generates all the structures that are needed.
22362 * The runtime then collects these partially filled structures.
22363 * The SWIG_InitializeModule function takes these initial arrays out of
22364 * swig_module, and does all the lookup, filling in the swig_module.types
22365 * array with the correct data and linking the correct swig_cast_info
22366 * structures together.
22367 *
22368 * The generated swig_type_info structures are assigned staticly to an initial
22369 * array. We just loop though that array, and handle each type individually.
22370 * First we lookup if this type has been already loaded, and if so, use the
22371 * loaded structure instead of the generated one. Then we have to fill in the
22372 * cast linked list. The cast data is initially stored in something like a
22373 * two-dimensional array. Each row corresponds to a type (there are the same
22374 * number of rows as there are in the swig_type_initial array). Each entry in
22375 * a column is one of the swig_cast_info structures for that type.
22376 * The cast_initial array is actually an array of arrays, because each row has
22377 * a variable number of columns. So to actually build the cast linked list,
22378 * we find the array of casts associated with the type, and loop through it
22379 * adding the casts to the list. The one last trick we need to do is making
22380 * sure the type pointer in the swig_cast_info struct is correct.
22381 *
22382 * First off, we lookup the cast->type name to see if it is already loaded.
22383 * There are three cases to handle:
22384 * 1) If the cast->type has already been loaded AND the type we are adding
22385 * casting info to has not been loaded (it is in this module), THEN we
22386 * replace the cast->type pointer with the type pointer that has already
22387 * been loaded.
22388 * 2) If BOTH types (the one we are adding casting info to, and the
22389 * cast->type) are loaded, THEN the cast info has already been loaded by
22390 * the previous module so we just ignore it.
22391 * 3) Finally, if cast->type has not already been loaded, then we add that
22392 * swig_cast_info to the linked list (because the cast->type) pointer will
22393 * be correct.
22394 * ----------------------------------------------------------------------------- */
22395
22396 #ifdef __cplusplus
22397 extern "C" {
22398 #if 0
22399 } /* c-mode */
22400 #endif
22401 #endif
22402
22403 #if 0
22404 #define SWIGRUNTIME_DEBUG
22405 #endif
22406
22407 SWIGRUNTIME void
22408 SWIG_InitializeModule(void *clientdata) {
22409 size_t i;
22410 swig_module_info *module_head;
22411 static int init_run = 0;
22412
22413 clientdata = clientdata;
22414
22415 if (init_run) return;
22416 init_run = 1;
22417
22418 /* Initialize the swig_module */
22419 swig_module.type_initial = swig_type_initial;
22420 swig_module.cast_initial = swig_cast_initial;
22421
22422 /* Try and load any already created modules */
22423 module_head = SWIG_GetModule(clientdata);
22424 if (module_head) {
22425 swig_module.next = module_head->next;
22426 module_head->next = &swig_module;
22427 } else {
22428 /* This is the first module loaded */
22429 swig_module.next = &swig_module;
22430 SWIG_SetModule(clientdata, &swig_module);
22431 }
22432
22433 /* Now work on filling in swig_module.types */
22434 #ifdef SWIGRUNTIME_DEBUG
22435 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22436 #endif
22437 for (i = 0; i < swig_module.size; ++i) {
22438 swig_type_info *type = 0;
22439 swig_type_info *ret;
22440 swig_cast_info *cast;
22441
22442 #ifdef SWIGRUNTIME_DEBUG
22443 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22444 #endif
22445
22446 /* if there is another module already loaded */
22447 if (swig_module.next != &swig_module) {
22448 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22449 }
22450 if (type) {
22451 /* Overwrite clientdata field */
22452 #ifdef SWIGRUNTIME_DEBUG
22453 printf("SWIG_InitializeModule: found type %s\n", type->name);
22454 #endif
22455 if (swig_module.type_initial[i]->clientdata) {
22456 type->clientdata = swig_module.type_initial[i]->clientdata;
22457 #ifdef SWIGRUNTIME_DEBUG
22458 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22459 #endif
22460 }
22461 } else {
22462 type = swig_module.type_initial[i];
22463 }
22464
22465 /* Insert casting types */
22466 cast = swig_module.cast_initial[i];
22467 while (cast->type) {
22468 /* Don't need to add information already in the list */
22469 ret = 0;
22470 #ifdef SWIGRUNTIME_DEBUG
22471 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22472 #endif
22473 if (swig_module.next != &swig_module) {
22474 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22475 #ifdef SWIGRUNTIME_DEBUG
22476 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22477 #endif
22478 }
22479 if (ret) {
22480 if (type == swig_module.type_initial[i]) {
22481 #ifdef SWIGRUNTIME_DEBUG
22482 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22483 #endif
22484 cast->type = ret;
22485 ret = 0;
22486 } else {
22487 /* Check for casting already in the list */
22488 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22489 #ifdef SWIGRUNTIME_DEBUG
22490 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22491 #endif
22492 if (!ocast) ret = 0;
22493 }
22494 }
22495
22496 if (!ret) {
22497 #ifdef SWIGRUNTIME_DEBUG
22498 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22499 #endif
22500 if (type->cast) {
22501 type->cast->prev = cast;
22502 cast->next = type->cast;
22503 }
22504 type->cast = cast;
22505 }
22506 cast++;
22507 }
22508 /* Set entry in modules->types array equal to the type */
22509 swig_module.types[i] = type;
22510 }
22511 swig_module.types[i] = 0;
22512
22513 #ifdef SWIGRUNTIME_DEBUG
22514 printf("**** SWIG_InitializeModule: Cast List ******\n");
22515 for (i = 0; i < swig_module.size; ++i) {
22516 int j = 0;
22517 swig_cast_info *cast = swig_module.cast_initial[i];
22518 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22519 while (cast->type) {
22520 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22521 cast++;
22522 ++j;
22523 }
22524 printf("---- Total casts: %d\n",j);
22525 }
22526 printf("**** SWIG_InitializeModule: Cast List ******\n");
22527 #endif
22528 }
22529
22530 /* This function will propagate the clientdata field of type to
22531 * any new swig_type_info structures that have been added into the list
22532 * of equivalent types. It is like calling
22533 * SWIG_TypeClientData(type, clientdata) a second time.
22534 */
22535 SWIGRUNTIME void
22536 SWIG_PropagateClientData(void) {
22537 size_t i;
22538 swig_cast_info *equiv;
22539 static int init_run = 0;
22540
22541 if (init_run) return;
22542 init_run = 1;
22543
22544 for (i = 0; i < swig_module.size; i++) {
22545 if (swig_module.types[i]->clientdata) {
22546 equiv = swig_module.types[i]->cast;
22547 while (equiv) {
22548 if (!equiv->converter) {
22549 if (equiv->type && !equiv->type->clientdata)
22550 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22551 }
22552 equiv = equiv->next;
22553 }
22554 }
22555 }
22556 }
22557
22558 #ifdef __cplusplus
22559 #if 0
22560 {
22561 /* c-mode */
22562 #endif
22563 }
22564 #endif
22565
22566
22567
22568 #ifdef __cplusplus
22569 extern "C" {
22570 #endif
22571
22572 /* Python-specific SWIG API */
22573 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22574 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22575 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22576
22577 /* -----------------------------------------------------------------------------
22578 * global variable support code.
22579 * ----------------------------------------------------------------------------- */
22580
22581 typedef struct swig_globalvar {
22582 char *name; /* Name of global variable */
22583 PyObject *(*get_attr)(void); /* Return the current value */
22584 int (*set_attr)(PyObject *); /* Set the value */
22585 struct swig_globalvar *next;
22586 } swig_globalvar;
22587
22588 typedef struct swig_varlinkobject {
22589 PyObject_HEAD
22590 swig_globalvar *vars;
22591 } swig_varlinkobject;
22592
22593 SWIGINTERN PyObject *
22594 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
22595 return PyString_FromString("<Swig global variables>");
22596 }
22597
22598 SWIGINTERN PyObject *
22599 swig_varlink_str(swig_varlinkobject *v) {
22600 PyObject *str = PyString_FromString("(");
22601 swig_globalvar *var;
22602 for (var = v->vars; var; var=var->next) {
22603 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22604 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22605 }
22606 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22607 return str;
22608 }
22609
22610 SWIGINTERN int
22611 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22612 PyObject *str = swig_varlink_str(v);
22613 fprintf(fp,"Swig global variables ");
22614 fprintf(fp,"%s\n", PyString_AsString(str));
22615 Py_DECREF(str);
22616 return 0;
22617 }
22618
22619 SWIGINTERN void
22620 swig_varlink_dealloc(swig_varlinkobject *v) {
22621 swig_globalvar *var = v->vars;
22622 while (var) {
22623 swig_globalvar *n = var->next;
22624 free(var->name);
22625 free(var);
22626 var = n;
22627 }
22628 }
22629
22630 SWIGINTERN PyObject *
22631 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22632 PyObject *res = NULL;
22633 swig_globalvar *var = v->vars;
22634 while (var) {
22635 if (strcmp(var->name,n) == 0) {
22636 res = (*var->get_attr)();
22637 break;
22638 }
22639 var = var->next;
22640 }
22641 if (res == NULL && !PyErr_Occurred()) {
22642 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22643 }
22644 return res;
22645 }
22646
22647 SWIGINTERN int
22648 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22649 int res = 1;
22650 swig_globalvar *var = v->vars;
22651 while (var) {
22652 if (strcmp(var->name,n) == 0) {
22653 res = (*var->set_attr)(p);
22654 break;
22655 }
22656 var = var->next;
22657 }
22658 if (res == 1 && !PyErr_Occurred()) {
22659 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22660 }
22661 return res;
22662 }
22663
22664 SWIGINTERN PyTypeObject*
22665 swig_varlink_type(void) {
22666 static char varlink__doc__[] = "Swig var link object";
22667 static PyTypeObject varlink_type;
22668 static int type_init = 0;
22669 if (!type_init) {
22670 const PyTypeObject tmp
22671 = {
22672 PyObject_HEAD_INIT(NULL)
22673 0, /* Number of items in variable part (ob_size) */
22674 (char *)"swigvarlink", /* Type name (tp_name) */
22675 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22676 0, /* Itemsize (tp_itemsize) */
22677 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
22678 (printfunc) swig_varlink_print, /* Print (tp_print) */
22679 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22680 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22681 0, /* tp_compare */
22682 (reprfunc) swig_varlink_repr, /* tp_repr */
22683 0, /* tp_as_number */
22684 0, /* tp_as_sequence */
22685 0, /* tp_as_mapping */
22686 0, /* tp_hash */
22687 0, /* tp_call */
22688 (reprfunc)swig_varlink_str, /* tp_str */
22689 0, /* tp_getattro */
22690 0, /* tp_setattro */
22691 0, /* tp_as_buffer */
22692 0, /* tp_flags */
22693 varlink__doc__, /* tp_doc */
22694 0, /* tp_traverse */
22695 0, /* tp_clear */
22696 0, /* tp_richcompare */
22697 0, /* tp_weaklistoffset */
22698 #if PY_VERSION_HEX >= 0x02020000
22699 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22700 #endif
22701 #if PY_VERSION_HEX >= 0x02030000
22702 0, /* tp_del */
22703 #endif
22704 #ifdef COUNT_ALLOCS
22705 0,0,0,0 /* tp_alloc -> tp_next */
22706 #endif
22707 };
22708 varlink_type = tmp;
22709 varlink_type.ob_type = &PyType_Type;
22710 type_init = 1;
22711 }
22712 return &varlink_type;
22713 }
22714
22715 /* Create a variable linking object for use later */
22716 SWIGINTERN PyObject *
22717 SWIG_Python_newvarlink(void) {
22718 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22719 if (result) {
22720 result->vars = 0;
22721 }
22722 return ((PyObject*) result);
22723 }
22724
22725 SWIGINTERN void
22726 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22727 swig_varlinkobject *v = (swig_varlinkobject *) p;
22728 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22729 if (gv) {
22730 size_t size = strlen(name)+1;
22731 gv->name = (char *)malloc(size);
22732 if (gv->name) {
22733 strncpy(gv->name,name,size);
22734 gv->get_attr = get_attr;
22735 gv->set_attr = set_attr;
22736 gv->next = v->vars;
22737 }
22738 }
22739 v->vars = gv;
22740 }
22741
22742 SWIGINTERN PyObject *
22743 SWIG_globals() {
22744 static PyObject *_SWIG_globals = 0;
22745 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
22746 return _SWIG_globals;
22747 }
22748
22749 /* -----------------------------------------------------------------------------
22750 * constants/methods manipulation
22751 * ----------------------------------------------------------------------------- */
22752
22753 /* Install Constants */
22754 SWIGINTERN void
22755 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22756 PyObject *obj = 0;
22757 size_t i;
22758 for (i = 0; constants[i].type; ++i) {
22759 switch(constants[i].type) {
22760 case SWIG_PY_POINTER:
22761 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22762 break;
22763 case SWIG_PY_BINARY:
22764 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22765 break;
22766 default:
22767 obj = 0;
22768 break;
22769 }
22770 if (obj) {
22771 PyDict_SetItemString(d, constants[i].name, obj);
22772 Py_DECREF(obj);
22773 }
22774 }
22775 }
22776
22777 /* -----------------------------------------------------------------------------*/
22778 /* Fix SwigMethods to carry the callback ptrs when needed */
22779 /* -----------------------------------------------------------------------------*/
22780
22781 SWIGINTERN void
22782 SWIG_Python_FixMethods(PyMethodDef *methods,
22783 swig_const_info *const_table,
22784 swig_type_info **types,
22785 swig_type_info **types_initial) {
22786 size_t i;
22787 for (i = 0; methods[i].ml_name; ++i) {
22788 char *c = methods[i].ml_doc;
22789 if (c && (c = strstr(c, "swig_ptr: "))) {
22790 int j;
22791 swig_const_info *ci = 0;
22792 char *name = c + 10;
22793 for (j = 0; const_table[j].type; ++j) {
22794 if (strncmp(const_table[j].name, name,
22795 strlen(const_table[j].name)) == 0) {
22796 ci = &(const_table[j]);
22797 break;
22798 }
22799 }
22800 if (ci) {
22801 size_t shift = (ci->ptype) - types;
22802 swig_type_info *ty = types_initial[shift];
22803 size_t ldoc = (c - methods[i].ml_doc);
22804 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22805 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22806 if (ndoc) {
22807 char *buff = ndoc;
22808 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22809 if (ptr) {
22810 strncpy(buff, methods[i].ml_doc, ldoc);
22811 buff += ldoc;
22812 strncpy(buff, "swig_ptr: ", 10);
22813 buff += 10;
22814 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22815 methods[i].ml_doc = ndoc;
22816 }
22817 }
22818 }
22819 }
22820 }
22821 }
22822
22823 #ifdef __cplusplus
22824 }
22825 #endif
22826
22827 /* -----------------------------------------------------------------------------*
22828 * Partial Init method
22829 * -----------------------------------------------------------------------------*/
22830
22831 #ifdef __cplusplus
22832 extern "C"
22833 #endif
22834 SWIGEXPORT void SWIG_init(void) {
22835 PyObject *m, *d;
22836
22837 /* Fix SwigMethods to carry the callback ptrs when needed */
22838 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
22839
22840 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22841 d = PyModule_GetDict(m);
22842
22843 SWIG_InitializeModule(0);
22844 SWIG_InstallConstants(d,swig_const_table);
22845
22846
22847 SWIG_Python_SetConstant(d, "GRID_VALUE_STRING",SWIG_FromCharPtr("string"));
22848 SWIG_Python_SetConstant(d, "GRID_VALUE_BOOL",SWIG_FromCharPtr("bool"));
22849 SWIG_Python_SetConstant(d, "GRID_VALUE_NUMBER",SWIG_FromCharPtr("long"));
22850 SWIG_Python_SetConstant(d, "GRID_VALUE_FLOAT",SWIG_FromCharPtr("double"));
22851 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICE",SWIG_FromCharPtr("choice"));
22852 SWIG_Python_SetConstant(d, "GRID_VALUE_TEXT",SWIG_FromCharPtr("string"));
22853 SWIG_Python_SetConstant(d, "GRID_VALUE_LONG",SWIG_FromCharPtr("long"));
22854 SWIG_Python_SetConstant(d, "GRID_VALUE_CHOICEINT",SWIG_FromCharPtr("choiceint"));
22855 SWIG_Python_SetConstant(d, "GRID_VALUE_DATETIME",SWIG_FromCharPtr("datetime"));
22856 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
22857 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellCoords",GridNoCellCoords_get, GridNoCellCoords_set);
22858 SWIG_addvarlink(SWIG_globals(),(char*)"GridNoCellRect",GridNoCellRect_get, GridNoCellRect_set);
22859 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_ROWS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_ROWS)));
22860 SWIG_Python_SetConstant(d, "GRID_DEFAULT_NUMBER_COLS",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_NUMBER_COLS)));
22861 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_HEIGHT)));
22862 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_WIDTH)));
22863 SWIG_Python_SetConstant(d, "GRID_DEFAULT_COL_LABEL_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_COL_LABEL_HEIGHT)));
22864 SWIG_Python_SetConstant(d, "GRID_DEFAULT_ROW_LABEL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_ROW_LABEL_WIDTH)));
22865 SWIG_Python_SetConstant(d, "GRID_LABEL_EDGE_ZONE",SWIG_From_int(static_cast< int >(wxGRID_LABEL_EDGE_ZONE)));
22866 SWIG_Python_SetConstant(d, "GRID_MIN_ROW_HEIGHT",SWIG_From_int(static_cast< int >(wxGRID_MIN_ROW_HEIGHT)));
22867 SWIG_Python_SetConstant(d, "GRID_MIN_COL_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_MIN_COL_WIDTH)));
22868 SWIG_Python_SetConstant(d, "GRID_DEFAULT_SCROLLBAR_WIDTH",SWIG_From_int(static_cast< int >(wxGRID_DEFAULT_SCROLLBAR_WIDTH)));
22869 SWIG_Python_SetConstant(d, "GridCellAttr_Any",SWIG_From_int(static_cast< int >(wxGridCellAttr::Any)));
22870 SWIG_Python_SetConstant(d, "GridCellAttr_Default",SWIG_From_int(static_cast< int >(wxGridCellAttr::Default)));
22871 SWIG_Python_SetConstant(d, "GridCellAttr_Cell",SWIG_From_int(static_cast< int >(wxGridCellAttr::Cell)));
22872 SWIG_Python_SetConstant(d, "GridCellAttr_Row",SWIG_From_int(static_cast< int >(wxGridCellAttr::Row)));
22873 SWIG_Python_SetConstant(d, "GridCellAttr_Col",SWIG_From_int(static_cast< int >(wxGridCellAttr::Col)));
22874 SWIG_Python_SetConstant(d, "GridCellAttr_Merged",SWIG_From_int(static_cast< int >(wxGridCellAttr::Merged)));
22875 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_GET_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)));
22876 SWIG_Python_SetConstant(d, "GRIDTABLE_REQUEST_VIEW_SEND_VALUES",SWIG_From_int(static_cast< int >(wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES)));
22877 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_INSERTED)));
22878 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_APPENDED)));
22879 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_ROWS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_ROWS_DELETED)));
22880 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_INSERTED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_INSERTED)));
22881 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_APPENDED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_APPENDED)));
22882 SWIG_Python_SetConstant(d, "GRIDTABLE_NOTIFY_COLS_DELETED",SWIG_From_int(static_cast< int >(wxGRIDTABLE_NOTIFY_COLS_DELETED)));
22883 SWIG_Python_SetConstant(d, "Grid_GridSelectCells",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectCells)));
22884 SWIG_Python_SetConstant(d, "Grid_GridSelectRows",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectRows)));
22885 SWIG_Python_SetConstant(d, "Grid_GridSelectColumns",SWIG_From_int(static_cast< int >(wxGrid::wxGridSelectColumns)));
22886 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
22887 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_CLICK));
22888 PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_DCLICK));
22889 PyDict_SetItemString(d, "wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_CELL_RIGHT_DCLICK));
22890 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_CLICK));
22891 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_CLICK));
22892 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_LEFT_DCLICK));
22893 PyDict_SetItemString(d, "wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong(wxEVT_GRID_LABEL_RIGHT_DCLICK));
22894 PyDict_SetItemString(d, "wxEVT_GRID_ROW_SIZE", PyInt_FromLong(wxEVT_GRID_ROW_SIZE));
22895 PyDict_SetItemString(d, "wxEVT_GRID_COL_SIZE", PyInt_FromLong(wxEVT_GRID_COL_SIZE));
22896 PyDict_SetItemString(d, "wxEVT_GRID_RANGE_SELECT", PyInt_FromLong(wxEVT_GRID_RANGE_SELECT));
22897 PyDict_SetItemString(d, "wxEVT_GRID_CELL_CHANGE", PyInt_FromLong(wxEVT_GRID_CELL_CHANGE));
22898 PyDict_SetItemString(d, "wxEVT_GRID_SELECT_CELL", PyInt_FromLong(wxEVT_GRID_SELECT_CELL));
22899 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong(wxEVT_GRID_EDITOR_SHOWN));
22900 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong(wxEVT_GRID_EDITOR_HIDDEN));
22901 PyDict_SetItemString(d, "wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong(wxEVT_GRID_EDITOR_CREATED));
22902 PyDict_SetItemString(d, "wxEVT_GRID_CELL_BEGIN_DRAG", PyInt_FromLong(wxEVT_GRID_CELL_BEGIN_DRAG));
22903
22904
22905 }
22906
wxWidgets (Impactor)